@mpgd/adapter-capacitor 0.7.5 → 0.9.0

package/dist/index.js

@@ -1,15 +1,21 @@
 import { decodeBridgeCredentialLoadData, decodeBridgeStorageLoadData, } from '@mpgd/bridge';
 import { CapacitorGameServices } from '@mpgd/capacitor-game-services';
 import { PlatformOperationError, } from '@mpgd/platform';
+import { deriveLegacyCommerceCapabilities } from '@mpgd/platform/commerce';
 import { createCapacitorAppEvents, } from './app-events.js';
+import { createBridgeCommerceProvider } from './commerce-bridge.js';
 import { assertProviderResponseData, createCapacitorProviderRegistry, } from './providers.js';
 import { createCapacitorViewport } from './viewport.js';
-export { createCapacitorProviderRegistry, } from './providers.js';
+export { createCapacitorProviderRegistry, createDegradedCommerceCapabilities, deriveCommerceFeatureStates, } from './providers.js';
+export { assertCommerceBridgeResult, commerceV2InvalidPayloadBridgeErrorCode, commerceV2MethodUnsupportedBridgeErrorCode, createBridgeCommerceProvider, createCommerceProviderBridge, createCommerceServiceProvider, } from './commerce-bridge.js';
+export { createStoreCommerceProvider, recoverableErrorCodes, } from './store-commerce-provider.js';
+export { defaultStoreSdkErrorCodeMap, normalizeStoreSdkError, } from './store-sdk.js';
 export { createCapacitorAppEvents, } from './app-events.js';
 export { CapacitorNativeHttpError, createCapacitorNativeJsonTransport, } from './native-http.js';
 export { createCapacitorViewport, } from './viewport.js';
 const externalActivityMethods = new Set([
     'commerce.purchase',
+    'commerce.v2.requestPurchase',
     'ads.showRewarded',
     'ads.showInterstitial',
     'identity.requestUpgrade',
@@ -18,6 +24,12 @@ const externalActivityMethods = new Set([
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+/**
+ * Upper bound on how long a `launched` commerce v2 purchase keeps the game
+ * paused when no purchase event for the product arrives (for example a store
+ * sheet dismissed without a callback).
+ */
+export const launchedPurchaseActivityTimeoutMs = 120_000;
 const safeFallbackMethods = new Set([
     'identity.getPlayer',
     'identity.getSession',
@@ -46,6 +58,17 @@ export function createCapacitorPlatformGateway(input) {
     const providers = createCapacitorProviderRegistry(input.providers ?? []);
     const adProvider = providers.byMethod.get('ads.showRewarded')?.adProvider
         ?? providers.byMethod.get('ads.showInterstitial')?.adProvider;
+    const commerceProvider = providers.commerce;
+    // The v2 surface is served through the same request path as every other
+    // provider method, so the bridge envelope, response validation, and external
+    // activity bookkeeping are exercised in process exactly as over a transport.
+    const commerceV2 = commerceProvider === undefined
+        ? undefined
+        : createBridgeCommerceProvider({
+            store: commerceProvider.commerce.store,
+            request: (method, payload) => request(method, payload),
+            subscribe: (listener) => commerceProvider.bridge.subscribe(listener),
+        });
     const lifecycle = createCapacitorAppEvents({
         target: input.target,
         ...(input.app === undefined ? {} : { app: input.app }),
@@ -59,10 +82,14 @@ export function createCapacitorPlatformGateway(input) {
     const viewport = input.viewport ?? createCapacitorViewport({
         ...(input.onAppEventError === undefined ? {} : { onError: input.onAppEventError }),
     });
+    const launchedPurchaseHolds = new Set();
     const gatewayLifecycle = {
         ...lifecycle,
         async dispose() {
             try {
+                for (const finish of [...launchedPurchaseHolds]) {
+                    finish();
+                }
                 await lifecycle.dispose?.();
             }
             finally {
@@ -76,6 +103,7 @@ export function createCapacitorPlatformGateway(input) {
         const releaseExternalActivity = externalActivityMethods.has(method)
             ? lifecycle.beginExternalActivity?.()
             : undefined;
+        let holdActivity = false;
         try {
             const provider = leaderboardRoute === 'remote'
                 && (method === 'leaderboard.submitScore' || method === 'leaderboard.open')
@@ -98,7 +126,17 @@ export function createCapacitorPlatformGateway(input) {
                 }
                 try {
                     await providers.assertMethodReady(method, payload, productType);
-                    return await sendRequest(method, payload, provider);
+                    const data = await sendRequest(method, payload, provider);
+                    if (releaseExternalActivity !== undefined
+                        && method === 'commerce.v2.requestPurchase'
+                        && isRecord(data) && data.outcome === 'launched') {
+                        // The store UI is still open: stay paused until this product's
+                        // purchase event arrives or the safety timeout ends. The v1 path
+                        // has no event to wait for and releases when its request returns.
+                        holdActivity = true;
+                        holdLaunchedPurchaseActivity(releaseExternalActivity, isRecord(payload) ? payload.logicalId : undefined);
+                    }
+                    return data;
                 }
                 catch (error) {
                     // Only non-mutating guest/status queries may degrade. A stale readiness
@@ -112,7 +150,53 @@ export function createCapacitorPlatformGateway(input) {
             return await sendRequest(method, payload, undefined);
         }
         finally {
-            releaseExternalActivity?.();
+            if (!holdActivity) {
+                releaseExternalActivity?.();
+            }
+        }
+    }
+    /**
+     * Keeps the external activity of a `launched` purchase open until the
+     * provider reports that product (`purchaseUpdated` or `purchaseError`, or an
+     * event without a logical id), the safety timeout ends, or the gateway is
+     * disposed. Every path releases exactly once.
+     */
+    function holdLaunchedPurchaseActivity(release, logicalId) {
+        let done = false;
+        let unsubscribe;
+        const finish = () => {
+            if (done) {
+                return;
+            }
+            done = true;
+            launchedPurchaseHolds.delete(finish);
+            clearTimeout(timer);
+            unsubscribe?.();
+            release();
+        };
+        launchedPurchaseHolds.add(finish);
+        const timer = setTimeout(finish, launchedPurchaseActivityTimeoutMs);
+        if (commerceProvider === undefined) {
+            return;
+        }
+        const subscription = commerceProvider.bridge.subscribe(({ event }) => {
+            if (event.type === 'subscriptionUpdated') {
+                return;
+            }
+            const eventLogicalId = event.type === 'purchaseUpdated'
+                ? event.purchase.logicalId
+                : event.logicalId;
+            if (eventLogicalId === undefined || typeof logicalId !== 'string'
+                || eventLogicalId === logicalId) {
+                finish();
+            }
+        });
+        // A buffered event may have finished the hold while subscribing.
+        if (done) {
+            subscription();
+        }
+        else {
+            unsubscribe = subscription;
         }
     }
     async function sendRequest(method, payload, provider) {
@@ -161,22 +245,28 @@ export function createCapacitorPlatformGateway(input) {
         target: input.target,
         async getCapabilities() {
             const base = await request('runtime.getCapabilities', {});
-            const states = await providers.getAvailability();
+            // One bounded registry read serves the feature states and the commerce
+            // block, so a stalled or invalid provider degrades the snapshot instead
+            // of rejecting it, and the boolean flags always follow the block.
+            const { availability: states, commerce } = await providers.getCapabilitySnapshot();
             const rewardedAds = states.rewardedAds === 'available';
             const interstitialAds = states.interstitialAds === 'available';
             const bannerAds = states.bannerAds === 'available';
+            const legacy = commerce === undefined ? undefined : deriveLegacyCommerceCapabilities(commerce);
             return {
                 ...base,
-                nativeIap: states.nativeIap === 'available',
-                subscriptionIap: states.subscriptionIap === 'available',
+                nativeIap: legacy?.nativeIap ?? states.nativeIap === 'available',
+                subscriptionIap: legacy?.subscriptionIap ?? states.subscriptionIap === 'available',
                 nativeAds: rewardedAds || interstitialAds || bannerAds,
                 rewardedAds,
                 interstitialAds,
                 bannerAds,
                 nativeLeaderboard: states.nativeLeaderboard === 'available',
                 providerAvailability: states,
+                ...(commerce === undefined ? {} : { commerce }),
             };
         },
+        ...(commerceV2 === undefined ? {} : { commerceV2 }),
         identity: {
             getPlayer: () => request('identity.getPlayer', {}),
             getSession: () => request('identity.getSession', {}),

package/dist/providers.d.ts

@@ -1,8 +1,14 @@
-import type { BridgeMethod, BridgeRequest, BridgeResponse } from '@mpgd/bridge';
+import { type BridgeEvent, type BridgeMethod, type BridgeRequest, type BridgeResponse } from '@mpgd/bridge';
 import type { AdProvider } from '@mpgd/platform/ads';
-import { type PlatformProviderAvailability, type PlatformProviderFeature, type ProductType } from '@mpgd/platform';
+import { type CommerceCapabilities, type PlatformProviderAvailability, type PlatformProviderFeature, type ProductType } from '@mpgd/platform';
+import { type CommerceProvider } from '@mpgd/platform/commerce';
 export interface NativeBridge {
   request(input: BridgeRequest): Promise<BridgeResponse>;
+  /**
+  * Optional commerce v2 event delivery (`{ protocol: 'mpgd.commerce.v2', sequence, event }`).
+  * B1 wires it for store providers; the base gateway works without it.
+  */
+  subscribe?(listener: (event: BridgeEvent) => void): () => void;
 }
 /**
 * An optional, separately installed provider handles only its declared bridge
@@ -12,17 +18,61 @@ export interface NativeBridge {
 */
 export interface CapacitorServiceProvider {
   readonly id: string;
+  /**
+  * Serves the declared `methods`. For a provider with `commerce`, it also
+  * serves the ten commerce bridge methods and must implement `subscribe`;
+  * `createCommerceServiceProvider` builds one from a `CommerceProvider`.
+  */
   readonly bridge: NativeBridge;
   readonly features: readonly PlatformProviderFeature[];
+  /**
+  * Declared v1 bridge methods. A provider with `commerce` declares no
+  * `commerce.*` method: the four v1 commerce methods and the six
+  * `commerce.v2.*` methods are implied and owned by the v2 provider.
+  */
   readonly methods: readonly BridgeMethod[];
   /** Optional native event surface. The base adapter never imports its SDK. */
   readonly adProvider?: AdProvider;
+  /**
+  * Optional commerce v2 provider (`createStoreCommerceProvider`). Its
+  * `getCapabilities()` is the readiness of the declared `nativeIap` and
+  * `subscriptionIap` features; `getAvailability` covers the other features.
+  */
+  readonly commerce?: CommerceProvider;
   getAvailability(): Promise<Readonly<Partial<Record<PlatformProviderFeature, PlatformProviderAvailability>>>>;
 }
+/** The provider the registry serves commerce v2 from. */
+export interface CapacitorCommerceServiceProvider extends CapacitorServiceProvider {
+  readonly commerce: CommerceProvider;
+  readonly bridge: NativeBridge & Required<Pick<NativeBridge, 'subscribe'>>;
+}
+export interface CapacitorProviderCapabilitySnapshot {
+  readonly availability: Readonly<Record<PlatformProviderFeature, PlatformProviderAvailability>>;
+  /**
+  * Present when a commerce v2 provider is registered: its validated
+  * `getCapabilities()` answer from the same bounded read that produced the
+  * `nativeIap` and `subscriptionIap` states, or a degraded block
+  * (`availability: 'temporarily-unavailable'`, nothing sold) when that read
+  * stalled, failed, or returned a shape the contract rejects.
+  */
+  readonly commerce?: CommerceCapabilities;
+}
 export interface CapacitorProviderRegistry {
   readonly byMethod: ReadonlyMap<BridgeMethod, CapacitorServiceProvider>;
+  /** The provider that serves commerce v2, when one is registered. */
+  readonly commerce?: CapacitorCommerceServiceProvider;
+  /** Feature readiness plus the commerce block, from one bounded read per provider. */
+  getCapabilitySnapshot(): Promise<CapacitorProviderCapabilitySnapshot>;
   assertMethodReady(method: BridgeMethod, payload?: unknown, productType?: ProductType): Promise<void>;
   getAvailability(): Promise<Readonly<Record<PlatformProviderFeature, PlatformProviderAvailability>>>;
 }
 export declare function createCapacitorProviderRegistry(input: readonly CapacitorServiceProvider[]): CapacitorProviderRegistry;
 export declare function assertProviderResponseData(method: BridgeMethod, data: unknown): void;
+/** The commerce block a gateway reports while its provider cannot be read. */
+export declare function createDegradedCommerceCapabilities(): CommerceCapabilities;
+/**
+* Readiness of the commerce features a v2 provider declares, from its own
+* capability declaration: a feature it does not sell is `unsupported`, and a
+* read that failed or stalled is `temporarily-unavailable`.
+*/
+export declare function deriveCommerceFeatureStates(capabilities: CommerceCapabilities | undefined, features: readonly PlatformProviderFeature[]): Partial<Record<PlatformProviderFeature, PlatformProviderAvailability>>;

package/dist/providers.js

@@ -1,5 +1,8 @@
+import { bridgeCommerceV2Methods, isBridgeCommerceV2Method, } from '@mpgd/bridge';
 import { isAdMobClientRewardEvidence } from '@mpgd/game-services/admob-client-reward';
 import { PlatformOperationError, } from '@mpgd/platform';
+import { createUnsupportedCommerceCapabilities, isCommerceCapabilities, } from '@mpgd/platform/commerce';
+import { assertCommerceBridgeResult } from './commerce-bridge.js';
 const featureMethods = {
     nativeIap: [
         'commerce.getProducts',
@@ -22,6 +25,12 @@ const featureMethods = {
 };
 const providerFeatures = Object.keys(featureMethods);
 const providerMethodSet = new Set(Object.values(featureMethods).flat());
+const commerceFeatures = ['nativeIap', 'subscriptionIap'];
+const v1CommerceMethods = featureMethods.nativeIap;
+const impliedCommerceMethods = [
+    ...v1CommerceMethods,
+    ...bridgeCommerceV2Methods,
+];
 const availabilitySet = new Set([
     'unsupported',
     'configuration-required',
@@ -40,12 +49,14 @@ export function createCapacitorProviderRegistry(input) {
     const byMethod = new Map();
     const byFeature = new Map();
     const ids = new Set();
+    let commerce;
     for (const provider of providers) {
         if (provider.id.trim() === '' || ids.has(provider.id)) {
             throw new Error(`Capacitor provider ID is empty or registered twice: ${provider.id}`);
         }
         ids.add(provider.id);
-        if (provider.features.length === 0 || provider.methods.length === 0) {
+        if (provider.features.length === 0
+            || (provider.methods.length === 0 && provider.commerce === undefined)) {
             throw new Error(`Capacitor provider ${provider.id} must declare features and methods.`);
         }
         const methods = new Set(provider.methods);
@@ -53,19 +64,44 @@ export function createCapacitorProviderRegistry(input) {
             throw new Error(`Capacitor provider ${provider.id} repeats a bridge method.`);
         }
         for (const method of methods) {
+            if (isBridgeCommerceV2Method(method)) {
+                // A v2 provider is registered through `commerce`; its bridge methods are implied.
+                throw new Error(`Capacitor provider ${provider.id} cannot declare commerce v2 method ${method}; `
+                    + 'register a v2 provider through `commerce` instead, commerce v2 is unavailable as '
+                    + 'a declared method.');
+            }
             if (!providerMethodSet.has(method)) {
                 throw new Error(`Capacitor provider ${provider.id} cannot replace base method ${method}.`);
             }
+            if (provider.commerce !== undefined && v1CommerceMethods.includes(method)) {
+                throw new Error(`Capacitor provider ${provider.id} cannot declare both a commerce v2 provider and `
+                    + `v1 method ${method}; the registry serves v1 callers from the v2 provider.`);
+            }
+        }
+        const implied = provider.commerce === undefined ? [] : impliedCommerceMethods;
+        for (const method of [...methods, ...implied]) {
             if (byMethod.has(method)) {
                 throw new Error(`Capacitor bridge method ${method} has multiple providers.`);
             }
         }
+        const owned = new Set([...methods, ...implied]);
+        if (provider.commerce !== undefined) {
+            if (!provider.features.some((feature) => commerceFeatures.includes(feature))) {
+                throw new Error(`Capacitor provider ${provider.id} declares a commerce v2 provider but no commerce feature.`);
+            }
+            if (provider.bridge.subscribe === undefined) {
+                // Without the event surface a purchase that completes after the store
+                // UI closed would never reach the reconciler.
+                throw new Error(`Capacitor provider ${provider.id} declares a commerce v2 provider but its bridge has no `
+                    + 'subscribe; build it with createCommerceServiceProvider.');
+            }
+        }
         for (const feature of provider.features) {
             const required = featureMethods[feature];
             if (required === undefined || byFeature.has(feature)) {
                 throw new Error(`Capacitor feature ${feature} has multiple or invalid providers.`);
             }
-            if (required.some((method) => !methods.has(method))) {
+            if (required.some((method) => !owned.has(method))) {
                 throw new Error(`Capacitor provider ${provider.id} lacks methods for ${feature}.`);
             }
             byFeature.set(feature, provider);
@@ -73,67 +109,80 @@ export function createCapacitorProviderRegistry(input) {
         if ([...methods].some((method) => !provider.features.some((feature) => featureMethods[feature].includes(method)))) {
             throw new Error(`Capacitor provider ${provider.id} declares an unowned method.`);
         }
-        for (const method of methods) {
+        for (const method of owned) {
             byMethod.set(method, provider);
         }
+        if (provider.commerce !== undefined) {
+            // Validated above: the bridge implements `subscribe`.
+            commerce = provider;
+        }
     }
     const readProviderStates = async (provider) => {
-        let reported;
-        let timer;
-        try {
-            reported = await Promise.race([
-                Promise.resolve().then(() => provider.getAvailability()),
-                new Promise((_resolve, reject) => {
-                    timer = setTimeout(() => reject(new Error('Provider availability timed out.')), availabilityTimeoutMs);
-                }),
-            ]);
-            if (!isRecord(reported)) {
-                throw new Error('Invalid provider availability.');
-            }
-        }
-        catch {
-            reported = {};
+        const states = {};
+        const commerceOwned = provider.commerce === undefined
+            ? []
+            : provider.features.filter((feature) => commerceFeatures.includes(feature));
+        const bridged = provider.features.filter((feature) => !commerceOwned.includes(feature));
+        let commerceBlock;
+        if (provider.commerce !== undefined && commerceOwned.length > 0) {
+            commerceBlock = await readCommerceCapabilities(provider.commerce);
+            Object.assign(states, deriveCommerceFeatureStates(commerceBlock, commerceOwned));
         }
-        finally {
-            if (timer !== undefined) {
-                clearTimeout(timer);
+        if (bridged.length > 0) {
+            const reported = await readWithTimeout(Promise.resolve().then(() => provider.getAvailability()));
+            for (const feature of bridged) {
+                const state = isRecord(reported) ? reported[feature] : undefined;
+                states[feature] = availabilitySet.has(state)
+                    ? state
+                    : 'temporarily-unavailable';
             }
         }
-        const states = {};
-        for (const feature of provider.features) {
-            const state = reported[feature];
-            states[feature] = availabilitySet.has(state)
-                ? state
-                : 'temporarily-unavailable';
-        }
-        return states;
+        return { states, ...(commerceBlock === undefined ? {} : { commerce: commerceBlock }) };
     };
-    const getAvailability = async () => {
+    const getCapabilitySnapshot = async () => {
         const states = {};
         for (const feature of providerFeatures) {
             states[feature] = 'unsupported';
         }
+        let commerceBlock;
         const snapshots = await Promise.all(providers.map(readProviderStates));
         for (const snapshot of snapshots) {
-            Object.assign(states, snapshot);
+            Object.assign(states, snapshot.states);
+            commerceBlock = snapshot.commerce ?? commerceBlock;
+        }
+        if (commerce !== undefined && commerceBlock === undefined) {
+            // One bounded read serves the feature states and the block, so a stalled,
+            // failed, or invalid provider degrades both the same way.
+            commerceBlock = createDegradedCommerceCapabilities();
         }
-        return states;
+        return {
+            availability: states,
+            ...(commerceBlock === undefined ? {} : { commerce: commerceBlock }),
+        };
     };
+    const getAvailability = async () => (await getCapabilitySnapshot()).availability;
     return {
         byMethod,
+        ...(commerce === undefined ? {} : { commerce }),
         getAvailability,
+        getCapabilitySnapshot,
         async assertMethodReady(method, payload, productType) {
             const provider = byMethod.get(method);
             if (provider === undefined) {
                 return;
             }
+            if (isBridgeCommerceV2Method(method)) {
+                // The v2 provider reads its own `availability` and fails closed before
+                // any store UI opens; the registry adds no second, stale snapshot.
+                return;
+            }
             if (method === 'ads.unmountBanner') {
                 // Teardown must reach the provider that mounted the banner even after
                 // its serving state becomes unavailable.
                 return;
             }
             // An unrelated provider must not delay a purchase, ad, or identity call.
-            const states = await readProviderStates(provider);
+            const { states } = await readProviderStates(provider);
             let relevant = provider.features.filter((feature) => featureMethods[feature].includes(method));
             if (method === 'commerce.purchase' && relevant.length > 1) {
                 relevant = relevant.filter((feature) => feature === (productType === 'subscription' ? 'subscriptionIap'
@@ -198,6 +247,73 @@ export function assertProviderResponseData(method, data) {
         });
     }
 }
+/**
+ * One bounded, validated capability read. A stalled, throwing, or invalid
+ * provider yields `undefined`; the block is copied so the gateway never hands
+ * out a provider-owned object.
+ */
+async function readCommerceCapabilities(provider) {
+    const reported = await readWithTimeout(Promise.resolve().then(() => provider.getCapabilities()));
+    if (!isCommerceCapabilities(reported)) {
+        return undefined;
+    }
+    return {
+        purchase: { ...reported.purchase },
+        catalog: { ...reported.catalog },
+        lifecycle: { ...reported.lifecycle },
+        authority: { ...reported.authority },
+        availability: reported.availability,
+    };
+}
+/** The commerce block a gateway reports while its provider cannot be read. */
+export function createDegradedCommerceCapabilities() {
+    return { ...createUnsupportedCommerceCapabilities(), availability: 'temporarily-unavailable' };
+}
+async function readWithTimeout(read) {
+    let timer;
+    try {
+        return await Promise.race([
+            read,
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new Error('Provider availability timed out.')), availabilityTimeoutMs);
+            }),
+        ]);
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+        }
+    }
+}
+/**
+ * Readiness of the commerce features a v2 provider declares, from its own
+ * capability declaration: a feature it does not sell is `unsupported`, and a
+ * read that failed or stalled is `temporarily-unavailable`.
+ */
+export function deriveCommerceFeatureStates(capabilities, features) {
+    const states = {};
+    const availability = capabilities === undefined
+        || !availabilitySet.has(capabilities.availability)
+        ? 'temporarily-unavailable'
+        : capabilities.availability;
+    for (const feature of features) {
+        if (feature === 'nativeIap') {
+            states.nativeIap = capabilities !== undefined
+                && !(capabilities.purchase.consumable || capabilities.purchase.durable)
+                ? 'unsupported'
+                : availability;
+        }
+        else if (feature === 'subscriptionIap') {
+            states.subscriptionIap = capabilities !== undefined && !capabilities.purchase.subscription
+                ? 'unsupported'
+                : availability;
+        }
+    }
+    return states;
+}
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -211,6 +327,15 @@ function isVoidData(value) {
     return value === undefined || value === null || (isRecord(value) && Object.keys(value).length === 0);
 }
 function isValidProviderData(method, value) {
+    if (isBridgeCommerceV2Method(method)) {
+        try {
+            assertCommerceBridgeResult(method, value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     switch (method) {
         case 'commerce.getProducts':
             return Array.isArray(value) && value.every((product) => isRecord(product)

package/dist/store-commerce-provider.d.ts

@@ -0,0 +1,55 @@
+import type { PlatformEvidenceEnvelope } from '@mpgd/platform';
+import { type CommerceAuthorityCapabilities, type CommerceCatalogCapabilities, type CommerceErrorCode, type CommerceLifecycleCapabilities, type CommerceLogicalProductId, type CommerceProvider, type CommercePurchaseCapabilities, type PurchaseKind, type StoreId, type StorePurchaseAccountBinding } from '@mpgd/platform/commerce';
+import { type StoreSdk, type StoreSdkErrorCodeMap, type StoreSdkPurchase } from './store-sdk.js';
+/** One catalog product sold through the store under `storeSku`. */
+export interface StoreCommerceProductMapping {
+  readonly logicalId: CommerceLogicalProductId;
+  readonly storeSku: string;
+  readonly kind: PurchaseKind;
+  /** Default store offer when the request names none. */
+  readonly offerId?: string;
+}
+/** Deep-partial overrides applied over the capabilities composed from the SDK declaration. */
+export interface StoreCommerceCapabilityOverrides {
+  readonly purchase?: Partial<CommercePurchaseCapabilities>;
+  readonly catalog?: Partial<CommerceCatalogCapabilities>;
+  readonly lifecycle?: Partial<CommerceLifecycleCapabilities>;
+}
+export interface CreateStoreCommerceProviderInput {
+  readonly sdk: StoreSdk;
+  /** Defaults to `sdk.store`. */
+  readonly store?: StoreId;
+  readonly products: readonly StoreCommerceProductMapping[];
+  /** Evidence schema the backend registry routes on, for example `google-play.product-purchase.v2`. */
+  readonly evidenceSchema: string;
+  /**
+  * Evidence payload for a purchase. Defaults to the token, transaction id,
+  * and SKU; a store provider replaces it to match its backend verifier.
+  */
+  readonly evidencePayload?: (purchase: StoreSdkPurchase) => PlatformEvidenceEnvelope['payload'];
+  /** Resolves the player's store account binding before a purchase opens. */
+  readonly accountBinding?: () => Promise<StorePurchaseAccountBinding | undefined>;
+  readonly capabilities?: StoreCommerceCapabilityOverrides;
+  readonly authority: CommerceAuthorityCapabilities;
+  /** Per-store error codes merged over `defaultStoreSdkErrorCodeMap`. */
+  readonly mapError?: StoreSdkErrorCodeMap;
+}
+export interface StoreCommerceProvider extends CommerceProvider {
+  /** Detaches the SDK listeners; buffered events are dropped. */
+  dispose(): void;
+}
+/**
+* `CommerceProvider` over an in-process `StoreSdk`. The provider maps logical
+* ids to store SKUs both ways, composes `CommerceCapabilities` from the SDK
+* declaration, builds `StorePurchase` evidence, buffers SDK events until the
+* first subscriber, and normalizes every SDK failure into a `CommerceError`.
+* It never grants and never sets `settlement`; the backend ledger decides.
+*/
+export declare function createStoreCommerceProvider(input: CreateStoreCommerceProviderInput): StoreCommerceProvider;
+/**
+* Codes that mean an unfinished purchase may exist (RFC "Errors": reconcile,
+* never reopen the store UI blindly). The attempt stays `launched` so the
+* reconciler resolves it from `getAvailablePurchases`; a terminal `failed`
+* would exclude it from recovery.
+*/
+export declare const recoverableErrorCodes: ReadonlySet<CommerceErrorCode>;