@mpgd/adapter-capacitor 0.8.0 → 0.9.0

package/dist/store-commerce-provider.js

@@ -0,0 +1,437 @@
+import { assertFinishTransactionInput, assertFinishTransactionResult, assertRequestPurchaseSupported, assertStoreProduct, assertStorePurchase, CommerceError, createCommerceEventBuffer, } from '@mpgd/platform/commerce';
+import { defaultStoreSdkErrorCodeMap, normalizeStoreSdkError, } from './store-sdk.js';
+const availabilityTimeoutMs = 3_000;
+const availabilitySet = new Set([
+    'unsupported',
+    'configuration-required',
+    'action-required',
+    'temporarily-unavailable',
+    'available',
+]);
+/**
+ * `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 function createStoreCommerceProvider(input) {
+    const { sdk } = input;
+    const store = input.store ?? sdk.store;
+    if (typeof store !== 'string' || store.length === 0) {
+        throw new TypeError('A store commerce provider requires a non-empty store id.');
+    }
+    if (typeof input.evidenceSchema !== 'string' || input.evidenceSchema.length === 0) {
+        throw new TypeError('A store commerce provider requires a non-empty evidence schema.');
+    }
+    const lifecycle = overrideLifecycle(sdk, input.capabilities);
+    const finishOwner = lifecycle.finish;
+    if ((finishOwner === 'client' || finishOwner === 'host') && sdk.finishTransaction === undefined) {
+        throw new TypeError(`Store ${store} declares finish '${finishOwner}' but the SDK has no finishTransaction.`);
+    }
+    if (lifecycle.restore && sdk.restorePurchases === undefined) {
+        // A capability the provider cannot serve is never advertised.
+        throw new TypeError(`Store ${store} declares lifecycle.restore but the SDK has no restorePurchases.`);
+    }
+    const bySku = new Map();
+    const byLogicalId = new Map();
+    for (const mapping of input.products) {
+        if (typeof mapping.logicalId !== 'string' || mapping.logicalId.length === 0
+            || typeof mapping.storeSku !== 'string' || mapping.storeSku.length === 0) {
+            throw new TypeError('Store product mappings require a logical id and a store SKU.');
+        }
+        if (bySku.has(mapping.storeSku) || byLogicalId.has(mapping.logicalId)) {
+            throw new TypeError(`Store product ${mapping.logicalId} (${mapping.storeSku}) is mapped twice.`);
+        }
+        bySku.set(mapping.storeSku, mapping);
+        byLogicalId.set(mapping.logicalId, mapping);
+    }
+    const mapError = Object.freeze({
+        ...defaultStoreSdkErrorCodeMap,
+        ...input.mapError,
+    });
+    const normalize = (error) => normalizeStoreSdkError(error, mapError);
+    const evidencePayload = input.evidencePayload ?? defaultEvidencePayload;
+    const toStorePurchase = (purchase) => {
+        if (!isRecord(purchase)) {
+            throw new CommerceError('INVALID_RESPONSE', {
+                message: `Store ${store} reported an invalid purchase.`,
+            });
+        }
+        const mapping = bySku.get(purchase.sku);
+        const candidate = {
+            store,
+            transactionId: purchase.transactionId,
+            ...(purchase.originalTransactionId === undefined
+                ? {}
+                : { originalTransactionId: purchase.originalTransactionId }),
+            storeSku: purchase.sku,
+            ...(mapping === undefined ? {} : { logicalId: mapping.logicalId }),
+            quantity: purchase.quantity,
+            state: purchase.state,
+            ...(purchase.purchasedAt === undefined ? {} : { purchasedAt: purchase.purchasedAt }),
+            token: purchase.token,
+            evidence: { schema: input.evidenceSchema, payload: evidencePayload(purchase) },
+            ...(purchase.accountBinding === undefined
+                ? {}
+                : { accountBinding: { ...purchase.accountBinding } }),
+        };
+        try {
+            return assertStorePurchase(candidate);
+        }
+        catch (error) {
+            throw new CommerceError('INVALID_RESPONSE', {
+                message: `Store ${store} reported an invalid purchase.`,
+                cause: error,
+            });
+        }
+    };
+    // Events: the SDK listeners attach at creation so a purchase reported before
+    // the first `subscribe` is buffered for it; while no listener is attached the
+    // buffer collects again.
+    const buffer = createCommerceEventBuffer();
+    const listeners = new Set();
+    const emit = (event) => {
+        if (listeners.size === 0) {
+            buffer.push(event);
+            return;
+        }
+        for (const listener of [...listeners]) {
+            listener(event);
+        }
+    };
+    const detachers = [
+        sdk.addListener('purchaseUpdated', (event) => {
+            let purchase;
+            try {
+                purchase = toStorePurchase(event.purchase);
+            }
+            catch (error) {
+                const mapping = isRecord(event.purchase) && typeof event.purchase.sku === 'string'
+                    ? bySku.get(event.purchase.sku)
+                    : undefined;
+                emit({
+                    type: 'purchaseError',
+                    ...(mapping === undefined ? {} : { logicalId: mapping.logicalId }),
+                    error: normalize(error).toCommerceErrorInfo(),
+                });
+                return;
+            }
+            emit({ type: 'purchaseUpdated', purchase });
+        }),
+        sdk.addListener('purchaseError', (event) => {
+            const mapping = typeof event.sku === 'string' ? bySku.get(event.sku) : undefined;
+            const error = normalize(event.error).toCommerceErrorInfo();
+            if (recoverableErrorCodes.has(error.code)) {
+                // An uncertain or already-owned attempt is not terminal: the reconciler
+                // resolves it from `getAvailablePurchases`, so the open record stays open.
+                return;
+            }
+            emit({
+                type: 'purchaseError',
+                ...(mapping === undefined ? {} : { logicalId: mapping.logicalId }),
+                error,
+            });
+        }),
+    ];
+    const getAvailability = sdk.getAvailability;
+    const readAvailability = async () => {
+        if (getAvailability === undefined) {
+            return 'available';
+        }
+        let timer;
+        try {
+            const reported = await Promise.race([
+                Promise.resolve().then(() => getAvailability.call(sdk)),
+                new Promise((_resolve, reject) => {
+                    timer = setTimeout(() => reject(new Error('Store availability timed out.')), availabilityTimeoutMs);
+                }),
+            ]);
+            return availabilitySet.has(reported)
+                ? reported
+                : 'temporarily-unavailable';
+        }
+        catch {
+            return 'temporarily-unavailable';
+        }
+        finally {
+            if (timer !== undefined) {
+                clearTimeout(timer);
+            }
+        }
+    };
+    const getCapabilities = async () => ({
+        purchase: { ...sdk.capabilities.purchase, ...input.capabilities?.purchase },
+        catalog: {
+            products: true,
+            offers: sdk.capabilities.offers ?? false,
+            localizedPrice: true,
+            ...input.capabilities?.catalog,
+        },
+        lifecycle: overrideLifecycle(sdk, input.capabilities),
+        authority: { ...input.authority },
+        availability: await readAvailability(),
+    });
+    const finishTransaction = sdk.finishTransaction;
+    const restorePurchases = sdk.restorePurchases;
+    const provider = {
+        store,
+        getCapabilities,
+        async fetchProducts(request = {}) {
+            const type = request.type ?? 'all';
+            const mappings = [...byLogicalId.values()].filter((mapping) => (request.logicalIds === undefined || request.logicalIds.includes(mapping.logicalId))
+                && (type === 'all'
+                    || (type === 'subscription') === (mapping.kind === 'subscription')));
+            if (mappings.length === 0) {
+                return [];
+            }
+            let reported;
+            try {
+                reported = await sdk.fetchProducts({
+                    skus: mappings.map((mapping) => mapping.storeSku),
+                    type,
+                });
+            }
+            catch (error) {
+                throw normalize(error);
+            }
+            if (!Array.isArray(reported)) {
+                throw new CommerceError('INVALID_RESPONSE', {
+                    message: `Store ${store} returned an invalid product list.`,
+                });
+            }
+            const products = [];
+            for (const product of reported) {
+                const mapping = isRecord(product) && typeof product.sku === 'string'
+                    ? bySku.get(product.sku)
+                    : undefined;
+                if (mapping === undefined || !mappings.includes(mapping)) {
+                    // A SKU the catalog does not sell is not a product the game can buy.
+                    continue;
+                }
+                if (product.kind !== mapping.kind) {
+                    throw new CommerceError('INVALID_RESPONSE', {
+                        message: `Store ${store} reports ${mapping.storeSku} as ${String(product.kind)}; the catalog declares ${mapping.kind}.`,
+                    });
+                }
+                try {
+                    products.push(assertStoreProduct({
+                        logicalId: mapping.logicalId,
+                        store,
+                        storeSku: mapping.storeSku,
+                        kind: mapping.kind,
+                        title: product.title,
+                        description: product.description,
+                        price: product.price,
+                        ...(product.offers === undefined ? {} : { offers: product.offers }),
+                    }));
+                }
+                catch (error) {
+                    throw new CommerceError('INVALID_RESPONSE', {
+                        message: `Store ${store} reported an invalid product for ${mapping.storeSku}.`,
+                        cause: error,
+                    });
+                }
+            }
+            return products;
+        },
+        async requestPurchase(request) {
+            const mapping = byLogicalId.get(request.logicalId);
+            if (mapping === undefined) {
+                throw new CommerceError('ITEM_UNAVAILABLE', {
+                    message: `Store ${store} does not sell ${request.logicalId}.`,
+                });
+            }
+            const capabilities = await getCapabilities();
+            assertAvailable(capabilities.availability, store);
+            assertRequestPurchaseSupported(capabilities, request, mapping.kind);
+            const accountBinding = await input.accountBinding?.();
+            if (input.authority.accountBinding === 'required' && accountBinding === undefined) {
+                throw new CommerceError('ACCOUNT_BINDING_REQUIRED', {
+                    message: `Store ${store} requires an account binding before a purchase.`,
+                });
+            }
+            const offerId = request.offerId ?? mapping.offerId;
+            let result;
+            try {
+                result = await sdk.requestPurchase({
+                    sku: mapping.storeSku,
+                    ...(offerId === undefined ? {} : { offerId }),
+                    ...(request.quantity === undefined ? {} : { quantity: request.quantity }),
+                    ...(accountBinding === undefined ? {} : { accountBinding }),
+                });
+            }
+            catch (error) {
+                return failureOutcome(undefined, normalize(error).toCommerceErrorInfo());
+            }
+            if (!isRecord(result)) {
+                throw invalidRequestResult(store);
+            }
+            switch (result.outcome) {
+                case 'launched':
+                    return { outcome: 'launched' };
+                case 'purchased':
+                    return { outcome: 'purchased', purchase: toStorePurchase(result.purchase) };
+                case 'cancelled':
+                case 'failed':
+                    return failureOutcome(result.outcome, normalize(result.error).toCommerceErrorInfo());
+                default:
+                    throw invalidRequestResult(store);
+            }
+        },
+        async getAvailablePurchases(request = {}) {
+            if (!overrideLifecycle(sdk, input.capabilities).availablePurchases) {
+                return [];
+            }
+            const includePending = request.includePending ?? false;
+            let reported;
+            try {
+                reported = await sdk.getAvailablePurchases({ includePending });
+            }
+            catch (error) {
+                throw normalize(error);
+            }
+            if (!Array.isArray(reported)) {
+                throw new CommerceError('INVALID_RESPONSE', {
+                    message: `Store ${store} returned an invalid purchase list.`,
+                });
+            }
+            const purchases = [];
+            for (const candidate of reported) {
+                const purchase = toStorePurchase(candidate);
+                // A revoked purchase is not recoverable, and a pending one is listed
+                // only on request; both still reach the reconciler through events.
+                if (purchase.state === 'revoked' || (purchase.state === 'pending' && !includePending)) {
+                    continue;
+                }
+                purchases.push(purchase);
+            }
+            return purchases;
+        },
+        ...(finishTransaction === undefined ? {} : {
+            async finishTransaction(request) {
+                // Finishing is authorized by a ledger entry only; the id is validated
+                // before the store hears about it.
+                const finish = assertFinishTransactionInput(request);
+                let reported;
+                try {
+                    reported = await finishTransaction.call(sdk, {
+                        transactionId: finish.transactionId,
+                        isConsumable: finish.isConsumable,
+                        ledgerEntryId: finish.ledgerEntryId,
+                    });
+                }
+                catch (error) {
+                    throw normalize(error);
+                }
+                try {
+                    return { finished: assertFinishTransactionResult(reported).finished };
+                }
+                catch (error) {
+                    throw new CommerceError('INVALID_RESPONSE', {
+                        message: `Store ${store} returned an invalid finish result.`,
+                        cause: error,
+                    });
+                }
+            },
+        }),
+        ...(restorePurchases === undefined ? {} : {
+            async restorePurchases() {
+                try {
+                    await restorePurchases.call(sdk);
+                }
+                catch (error) {
+                    throw normalize(error);
+                }
+            },
+        }),
+        subscribe(listener) {
+            listeners.add(listener);
+            if (listeners.size === 1) {
+                buffer.drain(listener);
+            }
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        dispose() {
+            for (const detach of detachers.splice(0, detachers.length)) {
+                detach();
+            }
+            listeners.clear();
+            buffer.drain(() => undefined);
+        },
+    };
+    return provider;
+}
+function overrideLifecycle(sdk, overrides) {
+    return {
+        availablePurchases: true,
+        pending: sdk.capabilities.pending,
+        restore: sdk.capabilities.restore && sdk.restorePurchases !== undefined,
+        events: true,
+        finish: sdk.capabilities.finish,
+        ...overrides?.lifecycle,
+    };
+}
+function defaultEvidencePayload(purchase) {
+    return {
+        token: purchase.token,
+        transactionId: purchase.transactionId,
+        storeSku: purchase.sku,
+        ...(purchase.originalTransactionId === undefined
+            ? {}
+            : { originalTransactionId: purchase.originalTransactionId }),
+    };
+}
+function assertAvailable(availability, store) {
+    switch (availability) {
+        case 'available':
+            return;
+        case 'configuration-required':
+            throw new CommerceError('CONFIGURATION_REQUIRED', {
+                message: `Store ${store} is not configured.`,
+            });
+        case 'action-required':
+            throw new CommerceError('ACTION_REQUIRED', {
+                message: `Store ${store} needs the player to act before a purchase.`,
+            });
+        case 'temporarily-unavailable':
+            throw new CommerceError('STORE_UNAVAILABLE', {
+                message: `Store ${store} is temporarily unavailable.`,
+                retryable: true,
+            });
+        case 'unsupported':
+            throw new CommerceError('STORE_UNAVAILABLE', {
+                message: `Store ${store} is unsupported on this device.`,
+                retryable: false,
+            });
+    }
+}
+/**
+ * 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 const recoverableErrorCodes = new Set([
+    'OUTCOME_UNKNOWN',
+    'ALREADY_OWNED',
+]);
+function failureOutcome(outcome, error) {
+    if (error.code === 'USER_CANCELLED') {
+        return { outcome: 'cancelled', error };
+    }
+    if (recoverableErrorCodes.has(error.code)) {
+        return { outcome: 'launched' };
+    }
+    return { outcome: outcome ?? 'failed', error };
+}
+function invalidRequestResult(store) {
+    return new CommerceError('INVALID_RESPONSE', {
+        message: `Store ${store} returned an invalid purchase result.`,
+    });
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/store-sdk.d.ts

@@ -0,0 +1,131 @@
+import type { PlatformProviderAvailability } from '@mpgd/platform';
+import { CommerceError, type CommerceErrorCode, type CommerceFinishOwner, type CommercePurchaseCapabilities, type FetchProductsType, type PurchaseKind, type StoreId, type StoreOffer, type StorePrice, type StorePurchaseAccountBinding, type StorePurchaseState } from '@mpgd/platform/commerce';
+/**
+* In-process surface a store plugin exposes to `createStoreCommerceProvider`.
+* The shape follows the OpenIAP Client Protocol (`fetchProducts`,
+* `requestPurchase` with results delivered by events, `getAvailablePurchases`,
+* `finishTransaction`) so a future Capacitor IAP plugin over the OpenIAP cores
+* is a drop-in, while the kit's Play Billing and StoreKit plugins adapt to it
+* in B2 and B3. The SDK speaks store SKUs only; the provider owns the mapping
+* to logical product ids, evidence, and capability composition. Nothing here
+* grants: a purchase reported by the SDK is evidence for the backend ledger.
+*/
+export interface StoreSdk {
+  readonly store: StoreId;
+  /** Static declaration of what the SDK supports; the provider composes `CommerceCapabilities` from it. */
+  readonly capabilities: StoreSdkCapabilities;
+  fetchProducts(input: StoreSdkFetchProductsInput): Promise<readonly StoreSdkProduct[]>;
+  /** Returns `launched` when the store UI opened and the result arrives as a `purchaseUpdated` event. */
+  requestPurchase(input: StoreSdkRequestPurchaseInput): Promise<StoreSdkRequestPurchaseResult>;
+  /** Purchases the store still reports as unfinished. */
+  getAvailablePurchases(input: StoreSdkGetAvailablePurchasesInput): Promise<readonly StoreSdkPurchase[]>;
+  /** Present when `capabilities.finish` is 'client' or 'host'. Called only after a ledger grant. */
+  finishTransaction?(input: StoreSdkFinishTransactionInput): Promise<StoreSdkFinishTransactionResult>;
+  /** Asks the store to resynchronize, for example `AppStore.sync`. */
+  restorePurchases?(): Promise<void>;
+  addListener<TEvent extends StoreSdkEventName>(eventName: TEvent, listener: (event: StoreSdkEventOf<TEvent>) => void): () => void;
+  /** Current readiness; omitted means the SDK is in-process and ready. */
+  getAvailability?(): Promise<PlatformProviderAvailability>;
+}
+export interface StoreSdkCapabilities {
+  readonly purchase: CommercePurchaseCapabilities;
+  /** The SDK reports store offers on products. Defaults to false. */
+  readonly offers?: boolean;
+  /** The store can report a purchase in state `pending` (for example deferred payment). */
+  readonly pending: boolean;
+  /** `restorePurchases` is implemented. */
+  readonly restore: boolean;
+  /** Who finishes a granted purchase; 'client' and 'host' require `finishTransaction`. */
+  readonly finish: CommerceFinishOwner;
+}
+export interface StoreSdkFetchProductsInput {
+  readonly skus: readonly string[];
+  readonly type: FetchProductsType;
+}
+export interface StoreSdkProduct {
+  readonly sku: string;
+  readonly kind: PurchaseKind;
+  readonly title: string;
+  readonly description: string;
+  readonly price: StorePrice;
+  readonly offers?: readonly StoreOffer[];
+}
+export interface StoreSdkRequestPurchaseInput {
+  readonly sku: string;
+  readonly offerId?: string;
+  readonly quantity?: number;
+  readonly accountBinding?: StorePurchaseAccountBinding;
+}
+export type StoreSdkRequestPurchaseResult = {
+  readonly outcome: 'launched';
+} | {
+  readonly outcome: 'purchased';
+  readonly purchase: StoreSdkPurchase;
+} | {
+  readonly outcome: 'cancelled' | 'failed';
+  readonly error: StoreSdkError;
+};
+export interface StoreSdkGetAvailablePurchasesInput {
+  readonly includePending?: boolean;
+}
+export interface StoreSdkPurchase {
+  readonly sku: string;
+  readonly transactionId: string;
+  readonly originalTransactionId?: string;
+  readonly state: StorePurchaseState;
+  readonly purchasedAt?: string;
+  /** Play purchase token, App Store signed transaction (JWS), or host order id. */
+  readonly token: string;
+  readonly quantity: number;
+  readonly accountBinding?: StorePurchaseAccountBinding;
+  /** Store-specific detail the provider never reads; kept for diagnostics only. */
+  readonly raw?: Readonly<Record<string, unknown>>;
+}
+export interface StoreSdkFinishTransactionInput {
+  readonly transactionId: string;
+  readonly isConsumable: boolean;
+  /** The ledger entry that authorized the finish; a plugin may record it. */
+  readonly ledgerEntryId: string;
+}
+export interface StoreSdkFinishTransactionResult {
+  readonly finished: boolean;
+}
+/**
+* Failure thrown or returned by an SDK. `code` is the store's own code (for
+* example `PLAY_BILLING_SERVICE_UNAVAILABLE`) or an already normalized
+* `CommerceErrorCode`; `storeCode` keeps the store code when `code` is already
+* normalized. `retryable` overrides the default of the normalized code.
+*/
+export interface StoreSdkError {
+  readonly code: string;
+  readonly message?: string;
+  readonly retryable?: boolean;
+  readonly storeCode?: string;
+}
+export type StoreSdkEvent = {
+  readonly type: 'purchaseUpdated';
+  readonly purchase: StoreSdkPurchase;
+} | {
+  readonly type: 'purchaseError';
+  readonly sku?: string;
+  readonly error: StoreSdkError;
+};
+export type StoreSdkEventName = StoreSdkEvent['type'];
+export type StoreSdkEventOf<TName extends StoreSdkEventName> = Extract<StoreSdkEvent, {
+  readonly type: TName;
+}>;
+/** Store code to normalized code; a provider passes a per-store table merged over these defaults. */
+export type StoreSdkErrorCodeMap = Readonly<Record<string, CommerceErrorCode>>;
+/**
+* Default mapping from the kit's current Play Billing, StoreKit, and native
+* provider codes (RFC "Errors"). B2 and B3 extend it per store.
+*/
+export declare const defaultStoreSdkErrorCodeMap: StoreSdkErrorCodeMap;
+/**
+* Normalizes anything an SDK threw or returned into a `CommerceError`. A store
+* code found in `mapError` becomes the mapped code with the store code kept;
+* a code that is already a v2 code is kept as is; anything else is `UNKNOWN`
+* with the original code as `storeCode`. An explicit `retryable` wins over
+* the default of the normalized code.
+*/
+export declare function normalizeStoreSdkError(error: unknown, mapError?: StoreSdkErrorCodeMap): CommerceError;

package/dist/store-sdk.js

@@ -0,0 +1,83 @@
+import { CommerceError, commerceErrorInfoOf, isCommerceErrorCode, } from '@mpgd/platform/commerce';
+/**
+ * Default mapping from the kit's current Play Billing, StoreKit, and native
+ * provider codes (RFC "Errors"). B2 and B3 extend it per store.
+ */
+export const defaultStoreSdkErrorCodeMap = Object.freeze({
+    PLAY_BILLING_TIMEOUT: 'OUTCOME_UNKNOWN',
+    PLAY_BILLING_INTERRUPTED: 'OUTCOME_UNKNOWN',
+    PLAY_BILLING_EMPTY_PURCHASE: 'OUTCOME_UNKNOWN',
+    STOREKIT_PURCHASE_UNCERTAIN: 'OUTCOME_UNKNOWN',
+    PLAY_BILLING_ALREADY_OWNED: 'ALREADY_OWNED',
+    PLAY_BILLING_DISCONNECTED: 'STORE_UNAVAILABLE',
+    PLAY_BILLING_SERVICE_UNAVAILABLE: 'STORE_UNAVAILABLE',
+    PLAY_BILLING_UNAVAILABLE: 'STORE_UNAVAILABLE',
+    PLAY_BILLING_TRANSIENT_ERROR: 'STORE_UNAVAILABLE',
+    STOREKIT_UNAVAILABLE: 'STORE_UNAVAILABLE',
+    NATIVE_PROVIDER_TEMPORARILY_UNAVAILABLE: 'STORE_UNAVAILABLE',
+    NATIVE_PROVIDER_UNSUPPORTED: 'STORE_UNAVAILABLE',
+    PLAY_BILLING_NETWORK_ERROR: 'NETWORK',
+    NATIVE_PURCHASE_NETWORK_ERROR: 'NETWORK',
+    PLAY_BILLING_PRODUCT_UNKNOWN: 'ITEM_UNAVAILABLE',
+    PLAY_BILLING_PRODUCT_UNAVAILABLE: 'ITEM_UNAVAILABLE',
+    STOREKIT_PRODUCT_UNKNOWN: 'ITEM_UNAVAILABLE',
+    STOREKIT_PRODUCT_UNAVAILABLE: 'ITEM_UNAVAILABLE',
+    NATIVE_PROVIDER_PRODUCT_UNKNOWN: 'ITEM_UNAVAILABLE',
+    PLAY_BILLING_ACCOUNT_REQUIRED: 'ACCOUNT_BINDING_REQUIRED',
+    PLAY_BILLING_ACCOUNT_LOOKUP_FAILED: 'ACCOUNT_BINDING_REQUIRED',
+    PLAY_BILLING_CONFIGURATION_ERROR: 'CONFIGURATION_REQUIRED',
+    STOREKIT_CONFIGURATION_ERROR: 'CONFIGURATION_REQUIRED',
+    NATIVE_PROVIDER_CONFIGURATION_REQUIRED: 'CONFIGURATION_REQUIRED',
+    NATIVE_PROVIDER_ACTION_REQUIRED: 'ACTION_REQUIRED',
+    NATIVE_PROVIDER_NOT_READY: 'NOT_PREPARED',
+    PLAY_BILLING_EVIDENCE_INVALID: 'INVALID_RESPONSE',
+    STOREKIT_EVIDENCE_INVALID: 'INVALID_RESPONSE',
+    NATIVE_PROVIDER_INVALID_RESPONSE: 'INVALID_RESPONSE',
+});
+/**
+ * Normalizes anything an SDK threw or returned into a `CommerceError`. A store
+ * code found in `mapError` becomes the mapped code with the store code kept;
+ * a code that is already a v2 code is kept as is; anything else is `UNKNOWN`
+ * with the original code as `storeCode`. An explicit `retryable` wins over
+ * the default of the normalized code.
+ */
+export function normalizeStoreSdkError(error, mapError = defaultStoreSdkErrorCodeMap) {
+    if (error instanceof CommerceError) {
+        return error;
+    }
+    if (typeof error === 'object' && error !== null && !Array.isArray(error)) {
+        const record = error;
+        if (typeof record.code === 'string' && record.code.length > 0) {
+            const message = typeof record.message === 'string' ? record.message : undefined;
+            const retryable = typeof record.retryable === 'boolean' ? record.retryable : undefined;
+            const storeCode = typeof record.storeCode === 'string' ? record.storeCode : undefined;
+            const options = {
+                ...(message === undefined ? {} : { message }),
+                ...(retryable === undefined ? {} : { retryable }),
+                cause: error,
+            };
+            const mapped = Object.hasOwn(mapError, record.code) ? mapError[record.code] : undefined;
+            if (mapped !== undefined) {
+                return new CommerceError(mapped, { ...options, storeCode: storeCode ?? record.code });
+            }
+            if (isCommerceErrorCode(record.code)) {
+                return new CommerceError(record.code, {
+                    ...options,
+                    ...(storeCode === undefined ? {} : { storeCode }),
+                });
+            }
+            return new CommerceError('UNKNOWN', {
+                ...options,
+                retryable: retryable ?? false,
+                storeCode: storeCode ?? record.code,
+            });
+        }
+    }
+    const info = commerceErrorInfoOf(error);
+    return new CommerceError(info.code, {
+        retryable: info.retryable,
+        ...(info.storeCode === undefined ? {} : { storeCode: info.storeCode }),
+        ...(info.message === undefined ? {} : { message: info.message }),
+        cause: error,
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/adapter-capacitor",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Capacitor platform adapter for mpgd Android and iOS shells.",
   "license": "MIT",
   "repository": {
@@ -43,11 +43,11 @@
   ],
   "dependencies": {
     "@capacitor/app": "8.1.1",
-    "@mpgd/capacitor-game-services": "0.6.2",
-    "@mpgd/bridge": "0.12.0",
-    "@mpgd/platform": "0.19.0",
-    "@mpgd/game-services": "0.20.0",
-    "@mpgd/target-config": "0.21.2"
+    "@mpgd/bridge": "0.12.1",
+    "@mpgd/capacitor-game-services": "0.6.3",
+    "@mpgd/game-services": "0.21.0",
+    "@mpgd/platform": "0.20.0",
+    "@mpgd/target-config": "0.21.3"
   },
   "peerDependencies": {
     "@capacitor-community/admob": "^8.1.0",
@@ -64,7 +64,7 @@
     "ttsc": "0.30.4",
     "typescript": "7.0.2",
     "vitest": "^4.0.0",
-    "@mpgd/game-runtime": "0.6.2"
+    "@mpgd/game-runtime": "0.6.3"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",