@mpgd/capacitor-play-billing 0.2.3 → 0.3.1

package/README.md

@@ -13,15 +13,16 @@ This package is published for opt-in integration, but Kit's mock and compile
 checks do not establish live Play purchase behavior. Validate it in a
 game-owned Play Console project before relying on it in a published game.
 
-## Commerce v2 provider
+## Commerce provider
 
-Commerce v2 ([RFC](../../docs/specs/commerce/commerce-v2-rfc.md), PR B2) adds
-a `StoreSdk` over this plugin and a `CommerceProvider` built from it with
+Commerce ([RFC](../../docs/specs/commerce/commerce-v2-rfc.md)) is a `StoreSdk`
+over this plugin and a `CommerceProvider` built from it with
 `createStoreCommerceProvider` from `@mpgd/adapter-capacitor` (a peer
-dependency since 0.2.0). Register the service provider with the Capacitor
-gateway and it serves the six `commerce.v2.*` bridge methods as
-`gateway.commerceV2`, plus the four v1 `commerce.*` methods through
-`toCommerceAdapter`, so v1 callers keep working.
+dependency). Register the service provider with the Capacitor gateway and it
+serves the six `commerce.v2.*` bridge methods as `gateway.commerce`, reports
+its capability block in `getCapabilities().commerce`, and declares no
+`features` or `methods` of its own. The `@mpgd/game-services` reconciler
+drives it; a scene never calls it.
 
 ```ts
 import { createCapacitorPlatformGateway } from '@mpgd/adapter-capacitor';
@@ -66,10 +67,9 @@ the plugin code. `getAvailablePurchases` is `getPurchases` filtered to
 unfinished entries: `purchased` with `isAcknowledged: false`, plus `pending`
 when `includePending` is set; each carries `token = purchaseToken` and
 `transactionId = orderId`, or the `play-token-sha256:<hex>` token key until
-Play assigns an order id, so ledgers written by v1 deduplicate. A purchased
-entry from a 0.1 native build carries no `isAcknowledged`; an absent flag
-counts as unfinished so a paid purchase is never dropped during a staged
-upgrade. A purchase for a SKU that is not in `products` (a retired product)
+Play assigns an order id, so the same purchase deduplicates in the ledger. A
+purchased entry whose `isAcknowledged` flag is absent counts as unfinished so a
+paid purchase is never dropped. A purchase for a SKU that is not in `products` (a retired product)
 or a multi-line purchase has no logical id for the reconciler, so it is left
 out of the list and of events and handed to the optional `onUnmappedPurchase`
 diagnostics hook instead; the backend finalizer still sees it through the
@@ -79,8 +79,8 @@ purchase without an order id waits for the token digest, and later updates
 queue behind it), and a `cancelled` or `failed` update without a purchase is
 the plugin's late terminal result for a purchase call that already timed out
 (`PLAY_BILLING_TIMEOUT`), emitted as a `purchaseError` for that product so
-the attempt the timeout left open closes. `getAvailability` is the v1 logic
-(Android check, offer configuration, service state).
+the attempt the timeout left open closes. `getAvailability` reports the Android
+check, offer configuration, and service state.
 `playBillingStoreSdkErrorCodeMap` extends `defaultStoreSdkErrorCodeMap` with
 every other `PLAY_BILLING_*` code (`BUSY` is `IN_PROGRESS`, `OFFER_REQUIRED`
 and the invalid-product codes are `CONFIGURATION_REQUIRED`,
@@ -93,26 +93,32 @@ the attempt from `getAvailablePurchases` without reopening the store UI.
 `createCapacitorPlayBillingCommerceProvider({ products, accountBinding,
 plugin?, isAndroid?, store?, mapError? })` composes the provider: evidence
 schema `google-play.product-purchase.v2` with payload `{ purchaseToken }`,
-byte-identical to the v1 provider's evidence, so
-`createGooglePlayProductPurchaseBoundary` verifies both; authority
+which `createGooglePlayProductPurchaseBoundary` verifies; authority
 `{ evidence: 'client-token', accountBinding: 'required' }`; no
 `finishTransaction` and no `restorePurchases`. A thrown `accountBinding`
 lookup is `ACCOUNT_BINDING_REQUIRED` with `PLAY_BILLING_ACCOUNT_LOOKUP_FAILED`
 kept as the store code. `store` defaults to `google-play`; only a conformance
 harness overrides it, because the derived idempotency key follows the store
-id. The conformance test runs every store vector whose profile the Play
+id. `createPlayBillingCommerceCapabilities(availability)` (from
+`src/commerce-profile.ts`, which imports types only and no Capacitor code)
+returns the full `CommerceCapabilities` block this provider declares while the
+store reports `availability`, so a validator or server can read the profile
+without loading the plugin; a unit test keeps it equal to
+`provider.getCapabilities()`. The conformance test runs every store vector whose profile the Play
 capabilities can serve (`purchase-server-finish`) against a fake plugin,
 directly and through the gateway bridge path, and lists the skipped vectors
 with their reason: the client-finish, host-finish, adapter-settled, and
 server-push profiles need a finish owner or evidence authority Play does not
 have.
 
-The plugin surface gained the Billing Library 9.1.0 `Purchase` getters on
-every purchase (`getPurchases()`, `purchase()`, and `purchaseUpdated`):
+Every purchase the plugin reports (`getPurchases()`, `purchase()`, and
+`purchaseUpdated`) carries the Billing Library 9.1.0 `Purchase` getters
 `products`, `purchaseState`, `purchaseTime`, `quantity`, `isAcknowledged`,
 and `obfuscatedAccountId`, with `priceAmountMicros` on offers. The 0.1 names
-`productIds`, `state`, and `purchaseTimeMillis` carry the same values and are
-deprecated until the next major version. `purchaseUpdated` is now retained
+`productIds`, `state`, and `purchaseTimeMillis` were removed from the payload
+and the type. The TypeScript readers still accept them, so a web bundle that
+reaches a 0.1 native build first (a live update) keeps paid purchases
+readable; run `cap sync` after upgrading all the same. `purchaseUpdated` is retained
 until a listener consumes it, so a purchase that completes after the
 `purchase` call timed out, or before the web view attached its listener,
 still reaches the provider, and a cancel or non-OK result that arrives after
@@ -143,42 +149,25 @@ A build whose shell lacks the native module still runs: the plugin answers
 Capacitor's `UNIMPLEMENTED`, which the SDK reports as
 `configuration-required`, so no purchase UI opens.
 
-### Migrating from the v1 provider
-
-`createCapacitorPlayBillingProvider` and `recoverOwnedPlayPurchases` are
-unchanged and keep working; both providers can share the plugin. Games that
-move to v2 replace the v1 provider in `providers` with
-`createCapacitorPlayBillingServiceProvider`, turn `getObfuscatedAccountId`
-into an `accountBinding` resolver returning `{ kind: 'obfuscated-account-id',
-value }`, rename `id`/`storeId`/`type` to `logicalId`/`storeSku`/`kind`
-(`non_consumable` becomes `durable`) and `offerToken` to `offerId`, and stop
-calling `recoverOwnedPlayPurchases`: it is deprecated in favour of the single
-reconciler in `@mpgd/game-services` (`createCommerceReconciler`, behind
-`createGameServicesClient` and `monetizationRecovery.reconcile()` whenever
-`gateway.commerceV2` exists), which reads `getAvailablePurchases` and
-`purchaseUpdated` from the provider and verifies each purchase under the same
-`play-token-sha256` key. The backend contract is unchanged, since the
-evidence payload is the same; `src/commerce-reconciler-play-smoke.test.ts`
-shows both paths reaching the same outcomes over the fake plugin.
-
-## v1 provider
-
-The provider maps game logical product IDs to Play product IDs and requires a
-stable obfuscated account ID that agrees with the backend account resolver.
-When Play returns multiple eligible one-time offers, map an explicit
-`offerToken`; otherwise product lookup reports `PLAY_BILLING_OFFER_REQUIRED`
-instead of displaying a price for the wrong offer.
-`getOwnedPurchases()` returns provisional evidence for recovery after a missed
-callback or process restart. `recoverOwnedPlayPurchases({ provider, backend:
-backend.purchases, playerId })` submits completed owned purchases to the same
-authenticated backend using stable token-derived idempotency keys. Backend
-uncertainty stays pending for retry; `commerce.restore` deliberately returns
-no local entitlements. Pending Play purchases remain pending until Google
-reports purchased. The caller must not grant based on a native callback,
-`getOwnedPurchases()` result, or `commerce.restore` alone.
-If a launched purchase times out, is interrupted, or reports an already-owned
-item without a matching callback, the provider returns `pending`. Requery and
-recover owned purchases before offering another billing flow.
+### Migrating from v1
+
+Commerce v2 PR C4 removed the v1 provider and its recovery driver.
+
+| Removed | Replacement |
+| --- | --- |
+| `createCapacitorPlayBillingProvider`, `PlayBillingProviderOptions`, `CapacitorPlayBillingProvider`, `PlayBillingProductMapping`, `PlayBillingAvailability` | `createCapacitorPlayBillingServiceProvider` (registry entry) or `createCapacitorPlayBillingCommerceProvider`; rename `id`/`storeId`/`type` to `logicalId`/`storeSku`/`kind` (`non_consumable` becomes `durable`) and `offerToken` to `offerId`; `getObfuscatedAccountId` becomes an `accountBinding` resolver returning `{ kind: 'obfuscated-account-id', value }` |
+| `recoverOwnedPlayPurchases`, `getOwnedPurchases`, `OwnedPlayPurchase`, `RecoveredPlayPurchase`, `PlayPurchaseVerification`, `PlayPurchaseRecoveryBackend` | the reconciler in `@mpgd/game-services` (`createCommerceReconciler`, behind `createGameServicesClient` and `monetizationRecovery.reconcile()`), which reads `getAvailablePurchases` and `purchaseUpdated` from the provider and verifies each purchase under the same `play-token-sha256` key; the backend contract is unchanged because the evidence payload is the same |
+| `createGooglePlayTokenTransactionId` | `createGooglePlayTokenPurchaseKey` from `@mpgd/platform/commerce` (the same function) |
+| `gateway.commerceV2`, the v1 `commerce.*` bridge methods | `gateway.commerce` and the `commerce.v2.*` methods |
+| `features: ['nativeIap']` on the registry entry | none: the entry declares no `features` and its readiness is `getCapabilities().commerce` |
+| `PlayPurchase.productIds`, `.state`, `.purchaseTimeMillis` (plugin payload and TypeScript type) | `products`, `purchaseState`, `purchaseTime` |
+
+`src/commerce-reconciler-play-smoke.test.ts` shows the reconciler resubmitting
+owned purchases over the fake plugin: a purchased token is verified once, a
+pending purchase is never sent, a rejection is terminal, and an outage stays
+retryable.
+
+## Native compile check
 
 The Kit reference app includes an opt-in Gradle compile target, without
 bundling Billing into the base app:

package/android/src/main/java/dev/mpgd/capacitor/playbilling/CapacitorPlayBillingPlugin.java

@@ -340,20 +340,14 @@ public class CapacitorPlayBillingPlugin extends Plugin {
             products.put(productId);
         }
         String purchaseState = state == Purchase.PurchaseState.PURCHASED ? "purchased" : "pending";
-        // Billing 9.1.0 Purchase getters under their own names, plus the 0.1 names
-        // (productIds, state, purchaseTimeMillis) until the next major version.
+        // Billing 9.1.0 Purchase getters under their own names.
         JSObject encoded = new JSObject()
             .put("products", products)
-            .put("productIds", products)
             .put("purchaseToken", token)
             .put("purchaseState", purchaseState)
-            .put("state", purchaseState)
             .put("purchaseTime", purchase.getPurchaseTime())
             .put("quantity", purchase.getQuantity())
             .put("isAcknowledged", purchase.isAcknowledged());
-        if (purchase.getPurchaseTime() > 0) {
-            encoded.put("purchaseTimeMillis", purchase.getPurchaseTime());
-        }
         if (purchase.getOrderId() != null) {
             encoded.put("orderId", purchase.getOrderId());
         }

package/dist/commerce-profile.d.ts

@@ -0,0 +1,24 @@
+import type { StoreSdkCapabilities } from '@mpgd/adapter-capacitor';
+import type { CommerceAuthorityCapabilities, CommerceCapabilities, PlatformProviderAvailability } from '@mpgd/platform';
+/** The store id of the Play Billing `StoreSdk` (RFC "Capabilities", `google-play`). */
+export declare const googlePlayStoreId: 'google-play';
+/** The evidence schema the Google Play verifier in `@mpgd/game-services` routes on. */
+export declare const googlePlayProductPurchaseEvidenceSchema: 'google-play.product-purchase.v2';
+/**
+* What the Play Billing plugin supports (RFC "Capabilities" profile row for
+* `google-play`): one-time consumables and durables, no subscriptions, no
+* multi-quantity, pending purchases, no restore call, one-time offers, and a
+* server-owned finish (the backend acknowledges or consumes after the grant).
+*/
+export declare const playBillingStoreSdkCapabilities: StoreSdkCapabilities;
+/** RFC "Capabilities" profile row for `google-play`: the purchase token is the proof, bound to an obfuscated account id. */
+export declare const playBillingCommerceAuthority: CommerceAuthorityCapabilities;
+/**
+* The `CommerceCapabilities` block `createCapacitorPlayBillingCommerceProvider`
+* declares while the store reports `availability`: composed from
+* `playBillingStoreSdkCapabilities` and `playBillingCommerceAuthority` exactly
+* as `createStoreCommerceProvider` composes it (the provider has no capability
+* overrides, and the Play SDK has no `restorePurchases`). Returns a fresh object
+* on every call and has no side effects.
+*/
+export declare function createPlayBillingCommerceCapabilities(availability: PlatformProviderAvailability): CommerceCapabilities;

package/dist/commerce-profile.js

@@ -0,0 +1,51 @@
+/** The store id of the Play Billing `StoreSdk` (RFC "Capabilities", `google-play`). */
+export const googlePlayStoreId = 'google-play';
+/** The evidence schema the Google Play verifier in `@mpgd/game-services` routes on. */
+export const googlePlayProductPurchaseEvidenceSchema = 'google-play.product-purchase.v2';
+/**
+ * What the Play Billing plugin supports (RFC "Capabilities" profile row for
+ * `google-play`): one-time consumables and durables, no subscriptions, no
+ * multi-quantity, pending purchases, no restore call, one-time offers, and a
+ * server-owned finish (the backend acknowledges or consumes after the grant).
+ */
+export const playBillingStoreSdkCapabilities = Object.freeze({
+    purchase: Object.freeze({
+        consumable: true,
+        durable: true,
+        subscription: false,
+        quantity: false,
+    }),
+    offers: true,
+    pending: true,
+    restore: false,
+    finish: 'server',
+});
+/** RFC "Capabilities" profile row for `google-play`: the purchase token is the proof, bound to an obfuscated account id. */
+export const playBillingCommerceAuthority = Object.freeze({
+    evidence: 'client-token',
+    accountBinding: 'required',
+});
+/**
+ * The `CommerceCapabilities` block `createCapacitorPlayBillingCommerceProvider`
+ * declares while the store reports `availability`: composed from
+ * `playBillingStoreSdkCapabilities` and `playBillingCommerceAuthority` exactly
+ * as `createStoreCommerceProvider` composes it (the provider has no capability
+ * overrides, and the Play SDK has no `restorePurchases`). Returns a fresh object
+ * on every call and has no side effects.
+ */
+export function createPlayBillingCommerceCapabilities(availability) {
+    const sdk = playBillingStoreSdkCapabilities;
+    return {
+        purchase: { ...sdk.purchase },
+        catalog: { products: true, offers: sdk.offers ?? false, localizedPrice: true },
+        lifecycle: {
+            availablePurchases: true,
+            pending: sdk.pending,
+            restore: sdk.restore,
+            events: true,
+            finish: sdk.finish,
+        },
+        authority: { ...playBillingCommerceAuthority },
+        availability,
+    };
+}

package/dist/commerce-provider.d.ts

@@ -1,17 +1,14 @@
 import { type CapacitorCommerceServiceProvider, type StoreCommerceProductMapping, type StoreCommerceProvider, type StoreSdkErrorCodeMap, type StoreSdkPurchase } from '@mpgd/adapter-capacitor';
 import type { PlatformEvidenceEnvelope } from '@mpgd/platform';
-import { type CommerceAuthorityCapabilities, type StoreId, type StorePurchaseAccountBinding } from '@mpgd/platform/commerce';
+import { type StoreId, type StorePurchaseAccountBinding } from '@mpgd/platform/commerce';
+import { googlePlayProductPurchaseEvidenceSchema, playBillingCommerceAuthority } from './commerce-profile.js';
 import type { CapacitorPlayBillingPlugin, PlayPurchase } from './definitions.js';
-/** The evidence schema the Google Play verifier in `@mpgd/game-services` routes on. */
-export declare const googlePlayProductPurchaseEvidenceSchema: 'google-play.product-purchase.v2';
-/** RFC "Capabilities" profile row for `google-play`: the purchase token is the proof, bound to an obfuscated account id. */
-export declare const playBillingCommerceAuthority: CommerceAuthorityCapabilities;
+export { googlePlayProductPurchaseEvidenceSchema, playBillingCommerceAuthority };
 /** The default registry id of the Play Billing commerce v2 service provider. */
 export declare const playBillingCommerceServiceProviderId: 'google-play-billing';
 /**
 * Evidence payload of a Play purchase: exactly `{ purchaseToken }`, which is
-* what `createGooglePlayProductPurchaseBoundary` reads and what the v1
-* provider emits, so v1 and v2 evidence verify through the same code path.
+* what `createGooglePlayProductPurchaseBoundary` reads.
 */
 export declare function createPlayBillingEvidencePayload(purchase: Pick<StoreSdkPurchase, 'token'>): PlatformEvidenceEnvelope['payload'];
 /** One catalog product sold through Play; `offerId` is the default one-time offer token. */
@@ -33,8 +30,8 @@ export interface CreateCapacitorPlayBillingCommerceProviderInput {
   readonly isAndroid?: () => boolean;
   /**
   * Store id on purchases and in derived idempotency keys. Defaults to
-  * `google-play`, which keeps the `play-token-sha256:<hex>` key v1 ledgers
-  * use; a conformance harness sets the vector's fixture store id.
+  * `google-play`, which keeps the `play-token-sha256:<hex>` key existing ledgers
+  * hold; a conformance harness sets the vector's fixture store id.
   */
   readonly store?: StoreId;
   /** Extra plugin codes merged over `playBillingStoreSdkErrorCodeMap`. */
@@ -58,10 +55,9 @@ export interface CreateCapacitorPlayBillingServiceProviderInput extends CreateCa
 }
 /**
 * Registry entry for `createCapacitorPlatformGateway({ providers })`: the
-* gateway serves the six `commerce.v2.*` bridge methods and exposes
-* `gateway.commerceV2`, and v1 callers keep working through
-* `toCommerceAdapter`. Only `nativeIap` is declared; Play sells no
-* subscriptions in this release.
+* gateway serves the six `commerce.v2.*` bridge methods, exposes the provider
+* as `gateway.commerce`, and reports its capability block (Play sells no
+* subscriptions in this release).
 */
 export declare function createCapacitorPlayBillingServiceProvider(input: CreateCapacitorPlayBillingServiceProviderInput): CapacitorCommerceServiceProvider & {
   readonly commerce: StoreCommerceProvider;

package/dist/commerce-provider.js

@@ -1,19 +1,15 @@
 import { createCommerceServiceProvider, createStoreCommerceProvider, } from '@mpgd/adapter-capacitor';
 import { CommerceError, } from '@mpgd/platform/commerce';
+import { googlePlayProductPurchaseEvidenceSchema, playBillingCommerceAuthority, } from './commerce-profile.js';
 import { createCapacitorPlayBillingStoreSdk, googlePlayStoreId, playBillingStoreSdkErrorCodeMap, } from './store-sdk.js';
-/** The evidence schema the Google Play verifier in `@mpgd/game-services` routes on. */
-export const googlePlayProductPurchaseEvidenceSchema = 'google-play.product-purchase.v2';
-/** RFC "Capabilities" profile row for `google-play`: the purchase token is the proof, bound to an obfuscated account id. */
-export const playBillingCommerceAuthority = Object.freeze({
-    evidence: 'client-token',
-    accountBinding: 'required',
-});
+// The profile constants live in the SDK-free `commerce-profile.ts` so a tools
+// project can read them without loading Capacitor; they stay exported here.
+export { googlePlayProductPurchaseEvidenceSchema, playBillingCommerceAuthority };
 /** The default registry id of the Play Billing commerce v2 service provider. */
 export const playBillingCommerceServiceProviderId = 'google-play-billing';
 /**
  * Evidence payload of a Play purchase: exactly `{ purchaseToken }`, which is
- * what `createGooglePlayProductPurchaseBoundary` reads and what the v1
- * provider emits, so v1 and v2 evidence verify through the same code path.
+ * what `createGooglePlayProductPurchaseBoundary` reads.
  */
 export function createPlayBillingEvidencePayload(purchase) {
     return { purchaseToken: purchase.token };
@@ -72,10 +68,9 @@ export function createCapacitorPlayBillingCommerceProvider(input) {
 }
 /**
  * Registry entry for `createCapacitorPlatformGateway({ providers })`: the
- * gateway serves the six `commerce.v2.*` bridge methods and exposes
- * `gateway.commerceV2`, and v1 callers keep working through
- * `toCommerceAdapter`. Only `nativeIap` is declared; Play sells no
- * subscriptions in this release.
+ * gateway serves the six `commerce.v2.*` bridge methods, exposes the provider
+ * as `gateway.commerce`, and reports its capability block (Play sells no
+ * subscriptions in this release).
  */
 export function createCapacitorPlayBillingServiceProvider(input) {
     const { id, ...providerInput } = input;
@@ -84,7 +79,6 @@ export function createCapacitorPlayBillingServiceProvider(input) {
         ...createCommerceServiceProvider({
             id: id ?? playBillingCommerceServiceProviderId,
             commerce,
-            features: ['nativeIap'],
         }),
         commerce,
     };

package/dist/definitions.d.ts

@@ -17,26 +17,18 @@ export interface PlayProduct {
 /**
 * One Play purchase as the plugin encodes `com.android.billingclient.api.Purchase`.
 * `products`, `purchaseState`, `purchaseTime`, `quantity`, `isAcknowledged`, and
-* `obfuscatedAccountId` follow the Billing Library 9.1.0 getters; `productIds`,
-* `state`, and `purchaseTimeMillis` are the 0.1 names and carry the same values
-* until the next major version.
+* `obfuscatedAccountId` follow the Billing Library 9.1.0 getters.
 */
 export interface PlayPurchase {
   /** `Purchase.getProducts()`: the product ids this purchase covers (one for a single-line purchase). */
   readonly products: readonly string[];
-  /** @deprecated Same value as `products`; removed in the next major version. */
-  readonly productIds: readonly string[];
   readonly purchaseToken: string;
   /** `Purchase.getOrderId()`; absent while Play has not assigned one (for example a pending purchase). */
   readonly orderId?: string;
   /** `Purchase.getPurchaseTime()` in milliseconds since the epoch. */
   readonly purchaseTime: number;
-  /** @deprecated Same value as `purchaseTime` when it is positive; removed in the next major version. */
-  readonly purchaseTimeMillis?: number;
   /** `Purchase.getPurchaseState()`; the plugin never reports `UNSPECIFIED_STATE`. */
   readonly purchaseState: PlayPurchaseState;
-  /** @deprecated Same value as `purchaseState`; removed in the next major version. */
-  readonly state: PlayPurchaseState;
   /**
   * `Purchase.isAcknowledged()`. The plugin never acknowledges or consumes; the
   * backend finalizer does after the ledger grant, so `false` on a purchased

package/dist/index.d.ts

@@ -1,5 +1,5 @@
+export { createPlayBillingCommerceCapabilities } from './commerce-profile.js';
 export * from './commerce-provider.js';
 export * from './definitions.js';
 export * from './plugin.js';
-export * from './provider.js';
 export * from './store-sdk.js';

package/dist/index.js

@@ -1,5 +1,5 @@
+export { createPlayBillingCommerceCapabilities } from './commerce-profile.js';
 export * from './commerce-provider.js';
 export * from './definitions.js';
 export * from './plugin.js';
-export * from './provider.js';
 export * from './store-sdk.js';

package/dist/store-sdk.d.ts

@@ -1,15 +1,8 @@
 import type { PlatformProviderAvailability } from '@mpgd/platform';
-import { type StoreSdk, type StoreSdkCapabilities, type StoreSdkError, type StoreSdkErrorCodeMap, type StoreSdkPurchase } from '@mpgd/adapter-capacitor';
+import { type StoreSdk, type StoreSdkError, type StoreSdkErrorCodeMap, type StoreSdkPurchase } from '@mpgd/adapter-capacitor';
 import type { CapacitorPlayBillingPlugin, PlayPurchase } from './definitions.js';
-/** The store id of the Play Billing `StoreSdk` (RFC "Capabilities", `google-play`). */
-export declare const googlePlayStoreId: 'google-play';
-/**
-* What the Play Billing plugin supports (RFC "Capabilities" profile row for
-* `google-play`): one-time consumables and durables, no subscriptions, no
-* multi-quantity, pending purchases, no restore call, one-time offers, and a
-* server-owned finish (the backend acknowledges or consumes after the grant).
-*/
-export declare const playBillingStoreSdkCapabilities: StoreSdkCapabilities;
+import { googlePlayStoreId, playBillingStoreSdkCapabilities } from './commerce-profile.js';
+export { googlePlayStoreId, playBillingStoreSdkCapabilities };
 /**
 * `defaultStoreSdkErrorCodeMap` plus every `PLAY_BILLING_*` code the plugin or
 * this SDK emits that the default map does not already normalize.
@@ -71,19 +64,18 @@ export declare class PlayBillingStoreSdkError extends Error implements StoreSdkE
 * provider normalizes (`PLAY_BILLING_TIMEOUT`, `PLAY_BILLING_INTERRUPTED`, and
 * `PLAY_BILLING_EMPTY_PURCHASE` become `OUTCOME_UNKNOWN` and stay recoverable).
 * `transactionId` is the order id or, until Play assigns one, the token key
-* `play-token-sha256:<hex>` v1 ledgers already use. Nothing here grants, and
+* `play-token-sha256:<hex>` existing ledgers already use. Nothing here grants, and
 * nothing here acknowledges or consumes: the backend finalizer owns both.
 */
 export declare function createCapacitorPlayBillingStoreSdk(input: CreateCapacitorPlayBillingStoreSdkInput): CapacitorPlayBillingStoreSdk;
-/** Validates a purchase token exactly as the v1 provider does. */
+/** Validates a Play purchase token: non-empty, at most 4096 characters, no padding or control characters. */
 export declare function isValidPlayPurchaseToken(value: unknown): value is string;
 /**
 * `StoreSdkPurchase` of one plugin purchase: `token` is the purchase token,
 * `transactionId` is the order id or the token key when Play has not assigned
-* one yet (the v1 rule, so ledgers written by v1 deduplicate), `purchasedAt`
+* one yet (so a purchase deduplicates in the ledger before and after Play assigns an order), `purchasedAt`
 * is `purchaseTime` as ISO 8601 when it is a valid instant, and the account
 * binding is the obfuscated account id the purchase flow recorded. Throws
 * `PLAY_BILLING_EVIDENCE_INVALID` for a shape the plugin never produces.
 */
 export declare function toPlayBillingSdkPurchase(purchase: PlayPurchase): Promise<StoreSdkPurchase>;
-export {};

package/dist/store-sdk.js

@@ -1,27 +1,11 @@
 import { Capacitor } from '@capacitor/core';
 import { defaultStoreSdkErrorCodeMap, } from '@mpgd/adapter-capacitor';
 import { createGooglePlayTokenPurchaseKey } from '@mpgd/platform/commerce';
+import { googlePlayStoreId, playBillingStoreSdkCapabilities } from './commerce-profile.js';
 import { CapacitorPlayBilling } from './plugin.js';
-/** The store id of the Play Billing `StoreSdk` (RFC "Capabilities", `google-play`). */
-export const googlePlayStoreId = 'google-play';
-/**
- * What the Play Billing plugin supports (RFC "Capabilities" profile row for
- * `google-play`): one-time consumables and durables, no subscriptions, no
- * multi-quantity, pending purchases, no restore call, one-time offers, and a
- * server-owned finish (the backend acknowledges or consumes after the grant).
- */
-export const playBillingStoreSdkCapabilities = Object.freeze({
-    purchase: Object.freeze({
-        consumable: true,
-        durable: true,
-        subscription: false,
-        quantity: false,
-    }),
-    offers: true,
-    pending: true,
-    restore: false,
-    finish: 'server',
-});
+// The profile constants live in the SDK-free `commerce-profile.ts` so a tools
+// project can read them without loading Capacitor; they stay exported here.
+export { googlePlayStoreId, playBillingStoreSdkCapabilities };
 /**
  * `defaultStoreSdkErrorCodeMap` plus every `PLAY_BILLING_*` code the plugin or
  * this SDK emits that the default map does not already normalize.
@@ -84,7 +68,7 @@ export class PlayBillingStoreSdkError extends Error {
  * provider normalizes (`PLAY_BILLING_TIMEOUT`, `PLAY_BILLING_INTERRUPTED`, and
  * `PLAY_BILLING_EMPTY_PURCHASE` become `OUTCOME_UNKNOWN` and stay recoverable).
  * `transactionId` is the order id or, until Play assigns one, the token key
- * `play-token-sha256:<hex>` v1 ledgers already use. Nothing here grants, and
+ * `play-token-sha256:<hex>` existing ledgers already use. Nothing here grants, and
  * nothing here acknowledges or consumes: the backend finalizer owns both.
  */
 export function createCapacitorPlayBillingStoreSdk(input) {
@@ -416,7 +400,7 @@ export function createCapacitorPlayBillingStoreSdk(input) {
     };
     return sdk;
 }
-/** Validates a purchase token exactly as the v1 provider does. */
+/** Validates a Play purchase token: non-empty, at most 4096 characters, no padding or control characters. */
 export function isValidPlayPurchaseToken(value) {
     return typeof value === 'string'
         && value.length > 0
@@ -427,7 +411,7 @@ export function isValidPlayPurchaseToken(value) {
 /**
  * `StoreSdkPurchase` of one plugin purchase: `token` is the purchase token,
  * `transactionId` is the order id or the token key when Play has not assigned
- * one yet (the v1 rule, so ledgers written by v1 deduplicate), `purchasedAt`
+ * one yet (so a purchase deduplicates in the ledger before and after Play assigns an order), `purchasedAt`
  * is `purchaseTime` as ISO 8601 when it is a valid instant, and the account
  * binding is the obfuscated account id the purchase flow recorded. Throws
  * `PLAY_BILLING_EVIDENCE_INVALID` for a shape the plugin never produces.
@@ -446,7 +430,7 @@ function convertPurchase(purchase) {
     if (!isRecord(purchase)) {
         throw evidenceInvalid('Play purchase is not an object.');
     }
-    const state = purchase.purchaseState ?? purchase.state;
+    const state = purchaseStateOf(purchase);
     if (state !== 'pending' && state !== 'purchased') {
         throw evidenceInvalid('Play purchase state is invalid.');
     }
@@ -502,11 +486,22 @@ function skuOf(purchase) {
     const sku = Array.isArray(products) && products.length === 1 ? products[0] : undefined;
     return typeof sku === 'string' && productIdPattern.test(sku) ? sku : undefined;
 }
+/**
+ * The purchase state under its Billing 9.1.0 name, or under the 0.1 name
+ * (`state`). The plugin's own native code sends only the current names; the
+ * 0.1 names (`state`, `productIds`, `purchaseTimeMillis`) are still read so a
+ * web bundle shipped ahead of its native binary, for example by a live
+ * update onto a 0.1 build, keeps every paid purchase readable and
+ * recoverable instead of rejecting it as invalid evidence.
+ */
+function purchaseStateOf(purchase) {
+    return purchase.purchaseState ?? purchase.state;
+}
 function isUnfinished(purchase, includePending) {
-    const state = purchase.purchaseState ?? purchase.state;
+    const state = purchaseStateOf(purchase);
     if (state === 'purchased') {
         // A 0.1 native build reports no flag; an absent flag is unfinished so a
-        // paid purchase is never dropped from recovery during a staged upgrade.
+        // paid purchase is never dropped from recovery.
         return purchase.isAcknowledged !== true;
     }
     return state === 'pending' && includePending;
@@ -519,7 +514,7 @@ function assertOutcomePurchase(outcome, expectedSku, expectedState) {
     if (skuOf(purchase) !== expectedSku) {
         throw evidenceInvalid('Play purchase did not match the requested product.');
     }
-    if ((purchase.purchaseState ?? purchase.state) !== expectedState) {
+    if (purchaseStateOf(purchase) !== expectedState) {
         throw evidenceInvalid('Play purchase state is inconsistent.');
     }
     return purchase;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/capacitor-play-billing",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "description": "Opt-in Android Google Play Billing purchase collector for mpgd Capacitor games.",
   "license": "MIT",
   "repository": {
@@ -38,20 +38,20 @@
   ],
   "peerDependencies": {
     "@capacitor/core": "^8.5.1",
-    "@mpgd/adapter-capacitor": "^0.9.3",
-    "@mpgd/bridge": "^0.12.3",
-    "@mpgd/platform": "^0.22.0"
+    "@mpgd/adapter-capacitor": "^0.10.1",
+    "@mpgd/bridge": "^0.13.1",
+    "@mpgd/platform": "^0.23.1"
   },
   "devDependencies": {
     "@capacitor/core": "8.5.2",
     "@types/node": "^24.0.0",
-    "ttsc": "0.30.4",
+    "ttsc": "0.32.1",
     "typescript": "7.0.2",
     "vitest": "^4.0.0",
-    "@mpgd/adapter-capacitor": "0.9.3",
-    "@mpgd/bridge": "0.12.3",
-    "@mpgd/platform": "0.22.0",
-    "@mpgd/game-services": "0.23.0"
+    "@mpgd/adapter-capacitor": "0.10.1",
+    "@mpgd/bridge": "0.13.1",
+    "@mpgd/game-services": "0.24.1",
+    "@mpgd/platform": "0.23.1"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -61,6 +61,6 @@
   "scripts": {
     "check": "ttsc --noEmit",
     "lint": "ttsc --noEmit",
-    "test": "vitest run && cd ../.. && node tools/run-ttsx.mjs --project native-plugins/capacitor-play-billing/tsconfig.json native-plugins/capacitor-play-billing/src/provider.test.ts"
+    "test": "vitest run"
   }
 }

package/dist/provider.d.ts

@@ -1,92 +0,0 @@
-import type { BridgeRequest, BridgeResponse } from '@mpgd/bridge';
-import type { PurchaseResult } from '@mpgd/platform';
-import type { CapacitorPlayBillingPlugin } from './definitions.js';
-export interface PlayBillingProductMapping {
-  readonly id: string;
-  readonly type: 'consumable' | 'non_consumable';
-  readonly storeId: string;
-  /** Required when Play lists multiple eligible purchase options or offers. */
-  readonly offerToken?: string;
-}
-export interface PlayBillingProviderOptions {
-  readonly products: readonly PlayBillingProductMapping[];
-  /** Must agree with the server's resolveObfuscatedAccountId mapping. */
-  readonly getObfuscatedAccountId: () => Promise<string> | string;
-  readonly sdk?: Pick<CapacitorPlayBillingPlugin, 'getProducts' | 'purchase' | 'getPurchases'>;
-  readonly isAndroid?: () => boolean;
-}
-export interface OwnedPlayPurchase {
-  readonly productId: string;
-  readonly result: PurchaseResult;
-  readonly purchasedAt?: string;
-}
-export type PlayBillingAvailability = 'available' | 'configuration-required' | 'temporarily-unavailable' | 'unsupported';
-export interface CapacitorPlayBillingProvider {
-  readonly id: 'google-play-billing';
-  readonly features: readonly ['nativeIap'];
-  readonly methods: readonly [
-    'commerce.getProducts',
-    'commerce.purchase',
-    'commerce.restore',
-    'commerce.getEntitlements'
-  ];
-  readonly bridge: {
-    request(input: BridgeRequest): Promise<BridgeResponse>;
-  };
-  getAvailability(): Promise<Readonly<{
-    nativeIap: PlayBillingAvailability;
-  }>>;
-  /** Requery owned, non-consumed transactions for game-owned backend recovery. */
-  getOwnedPurchases(): Promise<readonly OwnedPlayPurchase[]>;
-}
-export interface RecoveredPlayPurchase {
-  readonly productId: string;
-  readonly status: 'granted' | 'pending' | 'rejected';
-  readonly verification?: PlayPurchaseVerification;
-}
-export interface PlayPurchaseVerification {
-  readonly verified: boolean;
-  readonly disposition?: 'pending' | 'rejected';
-  readonly alreadyProcessed: boolean;
-  readonly ledgerEntryId?: string;
-  readonly reason?: string;
-}
-export interface PlayPurchaseRecoveryBackend {
-  verifyPurchase(input: {
-    readonly target: 'android';
-    readonly deploymentTarget?: string;
-    readonly playerId: string;
-    readonly productId: string;
-    readonly platformTransactionId: string;
-    readonly idempotencyKey: string;
-    readonly purchasedAt: string;
-    readonly evidence: NonNullable<PurchaseResult['evidence']>;
-  }): Promise<PlayPurchaseVerification>;
-}
-/**
-* Resubmit owned purchases after a callback was missed or the app restarted.
-* A native purchase is never credited locally; only the backend response grants it.
-*
-* @deprecated v1 recovery driver. Commerce v2 games register
-* `createCapacitorPlayBillingServiceProvider` and let the single reconciler
-* in `@mpgd/game-services` (PR C1) resolve unfinished purchases from
-* `getAvailablePurchases` and `purchaseUpdated`; this driver is removed with
-* the v1 adapter in the next major version.
-*/
-export declare function recoverOwnedPlayPurchases(input: {
-  readonly provider: CapacitorPlayBillingProvider;
-  readonly backend: PlayPurchaseRecoveryBackend;
-  readonly playerId: string;
-  readonly deploymentTarget?: string;
-  readonly now?: () => string;
-}): Promise<readonly RecoveredPlayPurchase[]>;
-export declare function createCapacitorPlayBillingProvider(options: PlayBillingProviderOptions): CapacitorPlayBillingProvider;
-/**
-* The server's token transaction ID, computed by the one shared helper so the
-* plugin and `@mpgd/game-services` can never drift.
-*
-* @deprecated Use `createGooglePlayTokenPurchaseKey` from `@mpgd/platform/commerce`;
-* this alias is the same function (same key, same `TypeError` for an invalid
-* token) and will be removed in the next major version.
-*/
-export declare const createGooglePlayTokenTransactionId: (purchaseToken: string) => Promise<string>;

package/dist/provider.js

@@ -1,303 +0,0 @@
-import { Capacitor } from '@capacitor/core';
-import { createGooglePlayTokenPurchaseKey } from '@mpgd/platform/commerce';
-import { CapacitorPlayBilling } from './plugin.js';
-const googlePlayProductPurchaseEvidenceSchema = 'google-play.product-purchase.v2';
-class PlayPurchaseIntegrityError extends Error {
-}
-function isValidPurchaseToken(value) {
-    return typeof value === 'string'
-        && value.length > 0
-        && value.length <= 4096
-        && value.trim() === value
-        && !/[\u0000-\u001f\u007f]/u.test(value);
-}
-/**
- * Resubmit owned purchases after a callback was missed or the app restarted.
- * A native purchase is never credited locally; only the backend response grants it.
- *
- * @deprecated v1 recovery driver. Commerce v2 games register
- * `createCapacitorPlayBillingServiceProvider` and let the single reconciler
- * in `@mpgd/game-services` (PR C1) resolve unfinished purchases from
- * `getAvailablePurchases` and `purchaseUpdated`; this driver is removed with
- * the v1 adapter in the next major version.
- */
-export async function recoverOwnedPlayPurchases(input) {
-    if (input.playerId.trim() === '') {
-        throw new TypeError('Recovery requires an authenticated player ID.');
-    }
-    const owned = await input.provider.getOwnedPurchases();
-    return Promise.all(owned.map(async ({ productId, result, purchasedAt }) => {
-        if (result.status === 'pending') {
-            return { productId, status: 'pending' };
-        }
-        if (result.status !== 'completed' || result.transactionId === undefined
-            || result.evidence === undefined) {
-            return { productId, status: 'rejected' };
-        }
-        const token = result.evidence.payload.purchaseToken;
-        if (typeof token !== 'string') {
-            return { productId, status: 'rejected' };
-        }
-        try {
-            const verification = await input.backend.verifyPurchase({
-                target: 'android',
-                ...(input.deploymentTarget === undefined ? {} : { deploymentTarget: input.deploymentTarget }),
-                playerId: input.playerId,
-                productId,
-                platformTransactionId: result.transactionId,
-                idempotencyKey: await createGooglePlayTokenPurchaseKey(token),
-                purchasedAt: purchasedAt ?? input.now?.() ?? new Date().toISOString(),
-                evidence: result.evidence,
-            });
-            return {
-                productId,
-                status: verification.verified ? 'granted' : (verification.disposition ?? 'pending'),
-                verification,
-            };
-        }
-        catch {
-            // Network or backend uncertainty must remain retryable, never rejected.
-            return { productId, status: 'pending' };
-        }
-    }));
-}
-export function createCapacitorPlayBillingProvider(options) {
-    const sdk = options.sdk ?? CapacitorPlayBilling;
-    const isAndroid = options.isAndroid ?? (() => Capacitor.getPlatform() === 'android');
-    const byLogicalId = new Map();
-    const byStoreId = new Map();
-    for (const product of options.products) {
-        if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(product.id)
-            || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(product.storeId)
-            || byLogicalId.has(product.id)
-            || byStoreId.has(product.storeId)) {
-            throw new TypeError('Play Billing product mappings must be unique and valid.');
-        }
-        byLogicalId.set(product.id, product);
-        byStoreId.set(product.storeId, product);
-    }
-    if (byLogicalId.size === 0) {
-        throw new TypeError('Play Billing requires at least one one-time product.');
-    }
-    if (byLogicalId.size > 100) {
-        throw new TypeError('Play Billing supports at most 100 products per provider.');
-    }
-    async function getOwnedPurchases() {
-        if (!isAndroid()) {
-            throw new Error('Play Billing is only available on Android.');
-        }
-        const response = await sdk.getPurchases();
-        const owned = [];
-        for (const purchase of response.purchases) {
-            if (purchase.productIds.length !== 1) {
-                continue;
-            }
-            const mapping = byStoreId.get(purchase.productIds[0] ?? '');
-            if (mapping !== undefined) {
-                const timestamp = purchase.purchaseTimeMillis;
-                const purchasedAt = typeof timestamp === 'number'
-                    && Number.isSafeInteger(timestamp)
-                    && timestamp > 0
-                    && timestamp <= 8_640_000_000_000_000
-                    ? new Date(timestamp).toISOString()
-                    : undefined;
-                owned.push({
-                    productId: mapping.id,
-                    result: await convertPurchase(purchase),
-                    ...(purchasedAt === undefined ? {} : { purchasedAt }),
-                });
-            }
-        }
-        return owned;
-    }
-    function selectOffer(mapping, found) {
-        if (mapping.offerToken === undefined) {
-            return found.offers.length === 1 ? found.offers[0] : undefined;
-        }
-        return found.offers.find((item) => item.offerToken === mapping.offerToken);
-    }
-    async function request(input) {
-        try {
-            if (!isAndroid()) {
-                return failure(input.id, 'PLAY_BILLING_ANDROID_REQUIRED');
-            }
-            switch (input.method) {
-                case 'commerce.getProducts': {
-                    const response = await sdk.getProducts({
-                        productIds: [...byStoreId.keys()],
-                    });
-                    const products = [];
-                    for (const found of response.products) {
-                        const mapping = byStoreId.get(found.productId);
-                        if (mapping === undefined) {
-                            continue;
-                        }
-                        const offer = selectOffer(mapping, found);
-                        if (offer === undefined) {
-                            return failure(input.id, 'PLAY_BILLING_OFFER_REQUIRED');
-                        }
-                        products.push({
-                            id: mapping.id,
-                            type: mapping.type,
-                            title: found.title,
-                            description: found.description,
-                            price: {
-                                formatted: offer.formattedPrice,
-                                currencyCode: offer.currencyCode,
-                            },
-                        });
-                    }
-                    return success(input.id, products);
-                }
-                case 'commerce.purchase': {
-                    const payload = input.payload;
-                    const productId = isRecord(payload) ? payload.productId : undefined;
-                    const mapping = typeof productId === 'string' ? byLogicalId.get(productId) : undefined;
-                    if (mapping === undefined) {
-                        return failure(input.id, 'PLAY_BILLING_PRODUCT_UNKNOWN');
-                    }
-                    let obfuscatedAccountId;
-                    try {
-                        obfuscatedAccountId = await options.getObfuscatedAccountId();
-                    }
-                    catch {
-                        return failure(input.id, 'PLAY_BILLING_ACCOUNT_LOOKUP_FAILED');
-                    }
-                    if (!/^[A-Za-z0-9._-]{1,64}$/u.test(obfuscatedAccountId)) {
-                        return failure(input.id, 'PLAY_BILLING_ACCOUNT_REQUIRED');
-                    }
-                    const outcome = await sdk.purchase({
-                        productId: mapping.storeId,
-                        obfuscatedAccountId,
-                        ...(mapping.offerToken === undefined ? {} : { offerToken: mapping.offerToken }),
-                    });
-                    return success(input.id, await convertOutcome(outcome, mapping.storeId));
-                }
-                case 'commerce.restore':
-                    // Native ownership is not an authoritative entitlement. The game
-                    // must submit getOwnedPurchases() results to its backend separately.
-                    return success(input.id, { restoredEntitlements: [] });
-                case 'commerce.getEntitlements':
-                    return success(input.id, []);
-                default:
-                    return failure(input.id, 'PLAY_BILLING_METHOD_UNSUPPORTED');
-            }
-        }
-        catch (error) {
-            if (error instanceof PlayPurchaseIntegrityError) {
-                return failure(input.id, 'PLAY_BILLING_EVIDENCE_INVALID');
-            }
-            const code = isRecord(error) ? error.code : undefined;
-            if (typeof code === 'string' && /^PLAY_BILLING_[A-Z_]+$/u.test(code)) {
-                if (input.method === 'commerce.purchase'
-                    && (code === 'PLAY_BILLING_TIMEOUT'
-                        || code === 'PLAY_BILLING_INTERRUPTED'
-                        || code === 'PLAY_BILLING_EMPTY_PURCHASE'
-                        || code === 'PLAY_BILLING_ALREADY_OWNED')) {
-                    // The purchase may have completed without an observed callback.
-                    // Requery owned purchases; never launch another flow blindly.
-                    return success(input.id, { status: 'pending', entitlementIds: [] });
-                }
-                const retryable = code === 'PLAY_BILLING_DISCONNECTED'
-                    || code === 'PLAY_BILLING_SERVICE_UNAVAILABLE'
-                    || code === 'PLAY_BILLING_NETWORK_ERROR'
-                    || code === 'PLAY_BILLING_TRANSIENT_ERROR';
-                return failure(input.id, code, retryable);
-            }
-            return failure(input.id, 'PLAY_BILLING_UNAVAILABLE', true);
-        }
-    }
-    return {
-        id: 'google-play-billing',
-        features: ['nativeIap'],
-        methods: [
-            'commerce.getProducts',
-            'commerce.purchase',
-            'commerce.restore',
-            'commerce.getEntitlements',
-        ],
-        bridge: { request },
-        async getAvailability() {
-            if (!isAndroid()) {
-                return { nativeIap: 'unsupported' };
-            }
-            try {
-                const response = await sdk.getProducts({ productIds: [...byStoreId.keys()] });
-                const hasPurchasableProduct = response.products.some((found) => {
-                    const mapping = byStoreId.get(found.productId);
-                    return mapping !== undefined && selectOffer(mapping, found) !== undefined;
-                });
-                return { nativeIap: hasPurchasableProduct ? 'available' : 'configuration-required' };
-            }
-            catch (error) {
-                const code = isRecord(error) ? error.code : undefined;
-                const configurationError = code === 'PLAY_BILLING_CONFIGURATION_ERROR'
-                    || code === 'PLAY_BILLING_PRODUCT_UNAVAILABLE'
-                    || code === 'PLAY_BILLING_OFFER_REQUIRED'
-                    || code === 'PLAY_BILLING_INVALID_PRODUCTS'
-                    || code === 'PLAY_BILLING_INVALID_PRODUCT';
-                return { nativeIap: configurationError
-                        ? 'configuration-required'
-                        : 'temporarily-unavailable' };
-            }
-        },
-        getOwnedPurchases,
-    };
-}
-async function convertOutcome(outcome, expectedStoreId) {
-    if (outcome.status === 'cancelled') {
-        return { status: 'cancelled', entitlementIds: [] };
-    }
-    const purchase = outcome.purchase;
-    if (purchase === undefined
-        || purchase.productIds.length !== 1
-        || purchase.productIds[0] !== expectedStoreId) {
-        throw new PlayPurchaseIntegrityError('Play purchase did not match the requested product.');
-    }
-    if ((outcome.status === 'purchased' && purchase.state !== 'purchased')
-        || (outcome.status === 'pending' && purchase.state !== 'pending')) {
-        throw new PlayPurchaseIntegrityError('Play purchase state is inconsistent.');
-    }
-    return convertPurchase(purchase);
-}
-async function convertPurchase(purchase) {
-    if (purchase.state !== 'pending' && purchase.state !== 'purchased') {
-        throw new PlayPurchaseIntegrityError('Play purchase state is invalid.');
-    }
-    if (!isValidPurchaseToken(purchase.purchaseToken)) {
-        throw new PlayPurchaseIntegrityError('Play purchase token is invalid.');
-    }
-    const evidence = {
-        schema: googlePlayProductPurchaseEvidenceSchema,
-        payload: { purchaseToken: purchase.purchaseToken },
-    };
-    if (purchase.state === 'pending') {
-        return { status: 'pending', entitlementIds: [], evidence };
-    }
-    const transactionId = purchase.orderId?.trim()
-        || await createGooglePlayTokenPurchaseKey(purchase.purchaseToken);
-    return {
-        status: 'completed',
-        transactionId,
-        entitlementIds: [],
-        evidence,
-    };
-}
-/**
- * The server's token transaction ID, computed by the one shared helper so the
- * plugin and `@mpgd/game-services` can never drift.
- *
- * @deprecated Use `createGooglePlayTokenPurchaseKey` from `@mpgd/platform/commerce`;
- * this alias is the same function (same key, same `TypeError` for an invalid
- * token) and will be removed in the next major version.
- */
-export const createGooglePlayTokenTransactionId = createGooglePlayTokenPurchaseKey;
-function success(id, data) {
-    return { id, ok: true, data };
-}
-function failure(id, code, retryable = false) {
-    return { id, ok: false, error: { code, message: code, retryable } };
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}