@mpgd/capacitor-storekit 0.4.5 → 0.6.0

package/README.md

@@ -61,10 +61,12 @@ once (a current non-consumable entitlement the native side marks
 still be verified; the server ledger dedupes. A finished consumable is not
 listed. A `revokedAt` maps to `state: 'revoked'`, and one malformed
 transaction is reported as a `purchaseError` without blocking its siblings);
-`finishTransaction({ transactionId, ledgerEntryId })` resolves the session
-app account token and finishes only a listed, non-revoked transaction bound
-to that token, or a durable of another token a restore shared to this
-player (see Recovery);
+`finishTransaction({ transactionId, ledgerEntryId, isConsumable, retry? })`
+resolves the session app account token and finishes only a listed,
+non-revoked transaction bound to that token, or a durable of another token a
+restore shared to this player (see Recovery), and on a retry (`retry: true`)
+answers `finished: true` without a native call for a consumable the list no
+longer carries (a lost acknowledgement, see Recovery);
 `restorePurchases` over `sync`; `transactionUpdated` as `purchaseUpdated`;
 and an availability probe as `getAvailability`, probing the configured
 SKUs batch by batch until one is sold. Every purchase carries the
@@ -105,7 +107,7 @@ consumables of another token stay excluded. The native
 or a `purchaseError` subscriber exists.
 
 `createCapacitorStoreKitCommerceProvider({ products, getAppAccountToken,
-bundleId?, sdk?, isIos?, mapError?, onDiagnostic? })` builds the provider
+purchaseGate?, bundleId?, sdk?, isIos?, mapError?, onDiagnostic? })` builds the provider
 with `authority: { evidence: 'client-token', accountBinding: 'required' }`
 and evidence `{ schema: 'app-store.signed-transaction.v1', payload: {
 signedTransaction, transactionId, originalTransactionId?, bundleId? } }`,
@@ -115,7 +117,18 @@ its `signedTransactionVerifier` (authenticity and transaction id binding)
 and then, by default, decides the grant on the transaction's current status
 from the App Store Server API, so a JWS retained from before a refund never
 grants; see the backend guide for the opt-in offline-only mode. Subscription
-mappings are rejected at construction. `createCapacitorStoreKitServiceProvider`
+mappings are rejected at construction. `getAppAccountToken` also filters
+recovery and finishing to the current player, so it must keep answering
+while sales are paused: pause new sales with the optional `purchaseGate`
+instead, which is asked only before a new purchase opens the StoreKit sheet
+(never by recovery, restore, or finishing) and refuses with `failed`,
+`ITEM_UNAVAILABLE`, and `PURCHASES_PAUSED` (see the adapter-capacitor
+README). With an adapter-capacitor from before
+the gate, which would ignore it, the plugin detects the missing gate support
+and answers every new purchase itself with a `failed` result, `ITEM_UNAVAILABLE` and
+`PURCHASE_GATE_UNSUPPORTED` instead of selling; recovery is unaffected.
+A token that cannot be resolved is a `failed` result with
+`STOREKIT_ACCOUNT_LOOKUP_FAILED` (a thrown `CommerceError` keeps its own code). `createCapacitorStoreKitServiceProvider`
 wraps the provider as a `CapacitorServiceProvider` (id `apple-storekit` by
 default, no `features`, no `methods`) so the gateway serves the six
 `commerce.v2.*` bridge methods from it, exposes it as `gateway.commerce`, and
@@ -131,13 +144,17 @@ Finishing never grants. The SDK finishes any transaction it is given a
 (`createCommerceReconciler` in `@mpgd/game-services`) is the gate, and it
 calls `finishTransaction` only for a journal record in `granted` or
 `finishing` that holds the ledger entry id the backend grant wrote
-(`assertCommerceFinishAllowed`). The journal revision the grant wrote is the
-pairing, and the real control stays server-side, in the verifier that checks
-the JWS before the ledger grant, and in the native plugin never granting
-anything on finish. `src/commerce-reconciler-storekit-smoke.test.ts` shows the
-reconciler over the fake plugin: a grant finishes with the ledger entry, a
-rejection and an outage never finish, a failed finish is retried, and another
-account's transaction is never submitted.
+(`assertCommerceFinishAllowed`), or for a `finished` consumable StoreKit
+lists again, with that same ledger entry (see Recovery). The journal revision
+the grant wrote is the pairing, and the real control stays server-side, in
+the verifier that checks the JWS before the ledger grant, and in the native
+plugin never granting anything on finish.
+`src/commerce-reconciler-storekit-smoke.test.ts` shows the reconciler over
+the fake plugin: a grant finishes with the ledger entry, a rejection and an
+outage never finish, a failed finish is retried, another account's
+transaction is never submitted, a finish whose answer was lost ends
+`finished` on the next run, a transaction listed again is finished again
+without a second verify, and an Ask to Buy purchase finishes once approved.
 
 The conformance test runs every store vector whose profile the App Store
 supports against a fake plugin, directly and through the gateway bridge path,
@@ -145,6 +162,45 @@ and lists each skipped vector with its reason (host or server finish,
 quantity, server-push, an asynchronous store error event StoreKit never
 emits, and a pending transaction state StoreKit never reports).
 
+### Purchase sheet facts
+
+The provider offers `CommerceProvider.presentation` (see "Store sheet facts"
+in the `@mpgd/adapter-capacitor` README), so the gateway keeps the game
+paused, and the game runtime keeps ads out, for the life of the purchase
+sheet rather than until a result event. The native plugin reports `open`
+right before OpenIAP calls `Product.purchase()` and `closed` when that call
+returns or throws, before it answers; a call it refuses earlier (invalid
+input, provider not ready, product unavailable) is `not-started`. An Ask to
+Buy (`pending`) is `closed` when the call returns; its purchase still arrives
+later through `transactionUpdated`. Facts reach JavaScript as
+`purchasePresentation` events (retained, keyed by a random id per call) and
+in the `presentation` field of the `purchase` answer or rejection data. The
+adapter adds a 15-minute safety timeout.
+
+Apple documents that `purchase(options:)` "displays the confirmation sheet"
+and returns a `PurchaseResult`
+([purchase(options:)](https://developer.apple.com/documentation/storekit/product/purchase(options:)),
+[purchase(confirmIn:options:)](https://developer.apple.com/documentation/storekit/product/purchase(confirmin:options:)-6dj6y)),
+but not that it returns only once the sheet is dismissed. `closed` therefore
+means "the purchase call ended"; that the sheet is gone by then is unverified
+until device testing.
+
+`getPresentationSupport` declares the facts. A web bundle running on a native
+build from before them (a live update) gets `UNIMPLEMENTED` there: while an
+adapter follows the facts, the store then reads `configuration-required` (the
+shop sells nothing and the reconciler spends no idempotency key), and a
+purchase that still gets through is refused with `CONFIGURATION_REQUIRED` /
+`STOREKIT_PRESENTATION_UNSUPPORTED` instead of opening a sheet the game would
+wait on; recovery is unaffected. `purchasePresentation: false` on the
+provider keeps the result-based pause of earlier releases.
+
+Device acceptance (not run; no device was available): the sheet cancelled, a
+completed purchase, an Ask to Buy request, the app backgrounded with the
+sheet up and resumed, and an iPad (sheet as a form sheet). Each must pause
+the game from `open` to `closed`, and `closed` must not arrive while the sheet
+is still visible. The steps and expected signals are in the kit's
+[purchase device acceptance checklist](https://github.com/imjlk/mpgd-kit/blob/main/docs/PURCHASE_DEVICE_ACCEPTANCE.md).
+
 ### Generated games
 
 Games generated by `mpgd game create` (and the kit's private starter) ship
@@ -211,6 +267,44 @@ separately on the server. `restorePurchases` invokes the user-initiated
 entitlements. Subscriptions are not supported by this package; they require a
 separate subscription status and renewal flow.
 
+A finish whose answer is lost after StoreKit applied it (the app is closed
+between the native finish and the journal write) leaves the record
+`finishing`. The reconciler's next finish of a record that was already
+`finishing` carries `retry: true`, and on a retry the SDK reads the
+consumable missing from `getTransactions` as finished: StoreKit keeps a
+transaction in
+[`Transaction.unfinished`](https://developer.apple.com/documentation/storekit/transaction/unfinished)
+until `finish()`, and a finished consumable is in neither that list nor
+`currentEntitlements`, so the SDK answers `finished: true` without a native
+call and the record ends `finished`. The first finish after the grant never
+does: right after a purchase the list may not carry the new transaction yet,
+so a missing one stays `{ finished: false }` and the reconciler retries (by
+then StoreKit lists it and it is finished natively). A caller that never
+sets `retry` (an older reconciler) keeps the earlier behaviour. The
+reconciler finishes only records holding a ledger grant, and nothing is
+verified again. A durable missing from the list is never answered finished
+(a finished durable stays listed with `unfinished: false`, so a missing one
+is revoked or unverifiable), nor is an entry of that id in a malformed
+shape. The kind of a missing transaction is the caller's `isConsumable`
+(the list no longer says, and reading `Transaction.all` would need a native
+change); a durable the catalog maps as a consumable never reaches a grant
+through this SDK, which excludes kind mismatches (`kind-mismatch`).
+
+Should StoreKit list the consumable again (an entry the native read skipped
+as unverifiable), the reconciler finishes it again with the journaled ledger
+entry, once per session, without a second verify. If the finished record has
+already left the journal (the generated game's journal keeps terminal
+records for 30 days), the transaction is verified under its derived key; the
+reference backend answers that with this player's recorded grant
+(`alreadyProcessed: true`, the same ledger entry, no second grant) because
+the App Store entry is a `client`-finish consumable, and the reconciler then
+finishes it. Another player's ask under another key stays refused
+(`EVIDENCE_ALREADY_PROCESSED`), so nothing is granted twice. Ask to Buy is
+unaffected: a deferred purchase has no transaction
+until it is approved, so its `launched` record holds no ledger grant and is
+never finished; the approved transaction arrives through `transactionUpdated`
+and is verified and finished once.
+
 ### Migrating from v1
 
 Commerce v2 PR C4 removed the v1 provider and its recovery driver.

package/dist/commerce-provider.d.ts

@@ -1,5 +1,6 @@
 import { type CapacitorCommerceServiceProvider, type StoreCommerceProductMapping, type StoreCommerceProvider, type StoreSdkErrorCodeMap } from '@mpgd/adapter-capacitor';
 import { appStoreSignedTransactionEvidenceSchema } from './commerce-profile.js';
+import { type StorePurchaseGate } from './purchase-gate-support.js';
 import { type CapacitorStoreKitDiagnostic, type CapacitorStoreKitStoreSdkPlugin } from './store-sdk.js';
 export { appStoreSignedTransactionEvidenceSchema };
 /** Payload of an `app-store.signed-transaction.v1` envelope. */
@@ -14,9 +15,18 @@ export interface CreateCapacitorStoreKitCommerceProviderInput {
   readonly products: readonly StoreCommerceProductMapping[];
   /**
   * Authenticated, stable UUID app account token of the current player. The
-  * backend's `resolveAppAccountToken` must resolve the same value.
+  * backend's `resolveAppAccountToken` must resolve the same value. It also
+  * filters recovery and finishing to this player, so it must keep answering
+  * while sales are paused; pause sales with `purchaseGate` instead.
   */
   readonly getAppAccountToken: () => string | Promise<string>;
+  /**
+  * Optional sales switch, asked before a new purchase opens the StoreKit
+  * sheet and never by recovery, restore, or finishing, which keep using
+  * `getAppAccountToken` alone; a refusal is `ITEM_UNAVAILABLE` with
+  * `PURCHASES_PAUSED` (see `StorePurchaseGate` in `@mpgd/adapter-capacitor`).
+  */
+  readonly purchaseGate?: StorePurchaseGate;
   /** Recorded in the evidence payload when known; the backend checks the signed value anyway. */
   readonly bundleId?: string;
   readonly sdk?: CapacitorStoreKitStoreSdkPlugin;
@@ -29,6 +39,16 @@ export interface CreateCapacitorStoreKitCommerceProviderInput {
   * types that disagree with the catalog kind. Diagnostics only.
   */
   readonly onDiagnostic?: (diagnostic: CapacitorStoreKitDiagnostic) => void;
+  /**
+  * Purchase sheet facts (default true): the provider offers `presentation`
+  * (`open` before `Product.purchase()`, `closed` when it returns or
+  * throws), so the gateway and the game runtime pause until the sheet is
+  * done, not until a result. Needs an app built with this package's native
+  * code (otherwise new purchases are refused with
+  * `STOREKIT_PRESENTATION_UNSUPPORTED`). False keeps the result-based pause
+  * of earlier releases.
+  */
+  readonly purchasePresentation?: boolean;
 }
 /**
 * Commerce v2 `CommerceProvider` for the App Store: `createStoreCommerceProvider`

package/dist/commerce-provider.js

@@ -1,6 +1,7 @@
 import { createCommerceServiceProvider, createStoreCommerceProvider, } from '@mpgd/adapter-capacitor';
 import { CommerceError } from '@mpgd/platform/commerce';
 import { appStoreSignedTransactionEvidenceSchema, appStoreStoreId, storeKitCommerceAuthority, } from './commerce-profile.js';
+import { refuseNewPurchasesUnlessGated, resolvePurchaseGateSupport, } from './purchase-gate-support.js';
 import { capacitorStoreKitErrorCodeMap, createCapacitorStoreKitStoreSdk, readAppAccountToken, } from './store-sdk.js';
 // 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.
@@ -31,6 +32,7 @@ export function createCapacitorStoreKitCommerceProvider(input) {
         throw new TypeError('StoreKit bundleId must be a non-empty string when provided.');
     }
     const bundleId = input.bundleId;
+    const gate = resolvePurchaseGateSupport(input.purchaseGate);
     const sdk = createCapacitorStoreKitStoreSdk({
         products: input.products.map((product) => ({
             sku: product.storeSku,
@@ -40,8 +42,11 @@ export function createCapacitorStoreKitCommerceProvider(input) {
         ...(input.sdk === undefined ? {} : { sdk: input.sdk }),
         ...(input.isIos === undefined ? {} : { isIos: input.isIos }),
         ...(input.onDiagnostic === undefined ? {} : { onDiagnostic: input.onDiagnostic }),
+        ...(input.purchasePresentation === undefined
+            ? {}
+            : { purchasePresentation: input.purchasePresentation }),
     });
-    return createStoreCommerceProvider({
+    return refuseNewPurchasesUnlessGated(createStoreCommerceProvider({
         sdk,
         store: appStoreStoreId,
         products: input.products,
@@ -63,6 +68,9 @@ export function createCapacitorStoreKitCommerceProvider(input) {
                 value = await input.getAppAccountToken();
             }
             catch (error) {
+                if (error instanceof CommerceError) {
+                    throw error;
+                }
                 throw new CommerceError('ACCOUNT_BINDING_REQUIRED', {
                     message: 'The StoreKit app account token could not be resolved.',
                     storeCode: 'STOREKIT_ACCOUNT_LOOKUP_FAILED',
@@ -86,9 +94,10 @@ export function createCapacitorStoreKitCommerceProvider(input) {
                 });
             }
         },
+        ...(gate.purchaseGate === undefined ? {} : { purchaseGate: gate.purchaseGate }),
         authority: storeKitCommerceAuthority,
         mapError: { ...capacitorStoreKitErrorCodeMap, ...input.mapError },
-    });
+    }), gate);
 }
 /**
  * The commerce provider wrapped as a `CapacitorServiceProvider` for

package/dist/definitions.d.ts

@@ -26,12 +26,38 @@ export interface StoreKitTransaction {
   */
   readonly unfinished?: boolean;
 }
-export type StoreKitPurchaseOutcome = {
+export type StoreKitPurchaseOutcome = ({
   readonly status: 'purchased';
   readonly transaction: StoreKitTransaction;
 } | {
   readonly status: 'pending' | 'cancelled';
+}) & {
+  /**
+  * The purchase sheet when a `purchase` call with a `presentationId`
+  * answered (also in a rejection's `data`): `closed` once
+  * `Product.purchase()` returned or threw, `not-started` when the plugin
+  * refused before calling it.
+  */
+  readonly presentation?: StoreKitPurchaseAnswerPresentation;
 };
+export type StoreKitPurchasePresentationState = 'open' | 'closed' | 'not-started';
+export type StoreKitPurchaseAnswerPresentation = StoreKitPurchasePresentationState | 'requested';
+/**
+* A sheet fact for the `purchase` call that sent `presentationId`: `open`
+* right before `Product.purchase()`, `closed` when it returns or throws,
+* `not-started` when the plugin refused before it. Apple documents that the
+* call presents the confirmation sheet, not that it returns only once the
+* sheet is gone; see the README.
+*/
+export interface StoreKitPurchasePresentationEvent {
+  readonly presentationId: string;
+  readonly state: StoreKitPurchasePresentationState;
+  readonly reason?: 'interrupted';
+}
+/** What `getPresentationSupport` declares; `purchasePresentation` is the facts protocol version. */
+export interface StoreKitPresentationSupport {
+  readonly purchasePresentation: number;
+}
 export interface CapacitorStoreKitPlugin {
   getProducts(input: {
     readonly productIds: readonly string[];
@@ -41,7 +67,15 @@ export interface CapacitorStoreKitPlugin {
   purchase(input: {
     readonly productId: string;
     readonly appAccountToken: string;
+    /** Asks for this call's sheet facts (`purchasePresentation`); 1-64 of `[A-Za-z0-9-]`. */
+    readonly presentationId?: string;
   }): Promise<StoreKitPurchaseOutcome>;
+  /**
+  * Declares the sheet facts the native code reports. A native build from
+  * before them answers `UNIMPLEMENTED`; optional so a plugin double without
+  * it still type-checks, and then the SDK refuses purchases that need facts.
+  */
+  getPresentationSupport?(): Promise<StoreKitPresentationSupport>;
   /** Includes unfinished consumables and current non-consumable entitlements. */
   getTransactions(): Promise<{
     readonly transactions: readonly StoreKitTransaction[];
@@ -69,4 +103,6 @@ export interface CapacitorStoreKitPlugin {
     readonly finished: boolean;
   }>;
   addListener(eventName: 'transactionUpdated', listener: (event: StoreKitTransaction) => void): Promise<PluginListenerHandle>;
+  /** Sheet facts of `purchase` calls that sent a `presentationId`. */
+  addListener(eventName: 'purchasePresentation', listener: (event: StoreKitPurchasePresentationEvent) => void): Promise<PluginListenerHandle>;
 }

package/dist/index.d.ts

@@ -3,3 +3,4 @@ export * from './commerce-provider.js';
 export * from './definitions.js';
 export * from './plugin.js';
 export * from './store-sdk.js';
+export { purchaseGateUnsupportedStoreCode, type StorePurchaseGate, type StorePurchaseGateDecision, type StorePurchaseGateRequest, } from './purchase-gate-support.js';

package/dist/index.js

@@ -3,3 +3,4 @@ export * from './commerce-provider.js';
 export * from './definitions.js';
 export * from './plugin.js';
 export * from './store-sdk.js';
+export { purchaseGateUnsupportedStoreCode, } from './purchase-gate-support.js';

package/dist/purchase-gate-support.d.ts

@@ -0,0 +1,50 @@
+import { CommerceError, type CommerceLogicalProductId, type CommerceProvider, type PurchaseKind, type PurchaseSource, type StoreId } from '@mpgd/platform/commerce';
+/** What a purchase gate is asked about: one new purchase, before any store UI opens. */
+export interface StorePurchaseGateRequest {
+  readonly store: StoreId;
+  readonly logicalId: CommerceLogicalProductId;
+  readonly storeSku: string;
+  readonly kind: PurchaseKind;
+  readonly source: PurchaseSource;
+}
+/** A purchase gate's answer; see `StorePurchaseGateDecision` in `@mpgd/adapter-capacitor`. */
+export type StorePurchaseGateDecision = {
+  readonly allowed: true;
+} | {
+  readonly allowed: false;
+  readonly storeCode?: string;
+  readonly message?: string;
+  readonly retryable?: boolean;
+};
+/** The game's sales switch for new purchases; see `StorePurchaseGate` in `@mpgd/adapter-capacitor`. */
+export type StorePurchaseGate = (request: StorePurchaseGateRequest) => StorePurchaseGateDecision | Promise<StorePurchaseGateDecision>;
+/** `storeCode` of every new purchase refused because the adapter cannot run the gate. */
+export declare const purchaseGateUnsupportedStoreCode: 'PURCHASE_GATE_UNSUPPORTED';
+/**
+* Whether the installed `@mpgd/adapter-capacitor` runs `purchaseGate`. An
+* adapter from before the gate ignores the option and would keep selling, so
+* the probe reads an export the gate release added (`purchasesPausedStoreCode`)
+* through the module namespace, where a missing export is `undefined` rather
+* than a link error.
+*/
+export declare function adapterSupportsPurchaseGate(adapterExports?: object): boolean;
+export interface PurchaseGateSupport {
+  /** The gate to hand the adapter, when it runs one. */
+  readonly purchaseGate?: StorePurchaseGate;
+  /**
+  * Set when a gate was given but the adapter cannot run it: the plugin then
+  * answers every new purchase itself (`refuseNewPurchasesUnlessGated`).
+  */
+  readonly refuseNewPurchases: boolean;
+}
+/** Fails closed: a gate the adapter would ignore refuses every new purchase instead. */
+export declare function resolvePurchaseGateSupport(purchaseGate: StorePurchaseGate | undefined, supported?: boolean): PurchaseGateSupport;
+export declare function createPurchaseGateUnsupportedError(): CommerceError;
+/**
+* Refuses every new purchase at the plugin boundary when the adapter cannot
+* run the configured gate, before the adapter's `requestPurchase` (which
+* would open the store) is reached. The refusal is a `failed` result, not a
+* throw, so `PURCHASE_GATE_UNSUPPORTED` survives the bridge whatever the
+* adapter version. Recovery, finishing, restore, and events are untouched.
+*/
+export declare function refuseNewPurchasesUnlessGated<TProvider extends CommerceProvider>(provider: TProvider, support: PurchaseGateSupport): TProvider;

package/dist/purchase-gate-support.js

@@ -0,0 +1,50 @@
+import * as adapterCapacitor from '@mpgd/adapter-capacitor';
+import { CommerceError, } from '@mpgd/platform/commerce';
+/** `storeCode` of every new purchase refused because the adapter cannot run the gate. */
+export const purchaseGateUnsupportedStoreCode = 'PURCHASE_GATE_UNSUPPORTED';
+/**
+ * Whether the installed `@mpgd/adapter-capacitor` runs `purchaseGate`. An
+ * adapter from before the gate ignores the option and would keep selling, so
+ * the probe reads an export the gate release added (`purchasesPausedStoreCode`)
+ * through the module namespace, where a missing export is `undefined` rather
+ * than a link error.
+ */
+export function adapterSupportsPurchaseGate(adapterExports = adapterCapacitor) {
+    return typeof adapterExports.purchasesPausedStoreCode
+        === 'string';
+}
+/** Fails closed: a gate the adapter would ignore refuses every new purchase instead. */
+export function resolvePurchaseGateSupport(purchaseGate, supported = adapterSupportsPurchaseGate()) {
+    if (purchaseGate === undefined) {
+        return { refuseNewPurchases: false };
+    }
+    return supported ? { purchaseGate, refuseNewPurchases: false } : { refuseNewPurchases: true };
+}
+export function createPurchaseGateUnsupportedError() {
+    return new CommerceError('ITEM_UNAVAILABLE', {
+        message: 'A purchase gate is configured but @mpgd/adapter-capacitor is too old to run it; '
+            + 'new purchases are refused until the adapter is upgraded.',
+        storeCode: purchaseGateUnsupportedStoreCode,
+        retryable: false,
+    });
+}
+/**
+ * Refuses every new purchase at the plugin boundary when the adapter cannot
+ * run the configured gate, before the adapter's `requestPurchase` (which
+ * would open the store) is reached. The refusal is a `failed` result, not a
+ * throw, so `PURCHASE_GATE_UNSUPPORTED` survives the bridge whatever the
+ * adapter version. Recovery, finishing, restore, and events are untouched.
+ */
+export function refuseNewPurchasesUnlessGated(provider, support) {
+    if (!support.refuseNewPurchases) {
+        return provider;
+    }
+    return Object.assign(provider, {
+        async requestPurchase() {
+            return {
+                outcome: 'failed',
+                error: createPurchaseGateUnsupportedError().toCommerceErrorInfo(),
+            };
+        },
+    });
+}

package/dist/purchase-presentation.d.ts

@@ -0,0 +1,27 @@
+import type { PluginListenerHandle } from '@capacitor/core';
+export type StoreKitPurchasePresentationState = 'open' | 'closed' | 'not-started' | 'unknown';
+/** A sheet fact of one `requestPurchase` call; see `StoreSdkPurchasePresentationEvent`. */
+export interface StoreKitSdkPurchasePresentationEvent {
+  readonly presentationId: string;
+  readonly state: StoreKitPurchasePresentationState;
+  readonly reason?: 'interrupted' | 'timeout';
+}
+/** The SDK's `purchasePresentation`; see `StoreSdkPurchasePresentation` in `@mpgd/adapter-capacitor`. */
+export interface StoreKitSdkPurchasePresentation {
+  subscribe(listener: (event: StoreKitSdkPurchasePresentationEvent) => void): () => void;
+}
+/** See `NativePurchasePresentation` in `@mpgd/adapter-capacitor`. */
+export interface StoreKitNativePurchasePresentation {
+  readonly purchasePresentation: StoreKitSdkPurchasePresentation;
+  supported(): Promise<boolean>;
+  followed(): boolean;
+  begin(presentationId: string): void;
+  answered(presentationId: string, answerOrError: unknown): void;
+}
+/** The native surface the facts need: the plugin's event and support check. */
+export interface StoreKitNativePresentationPlugin {
+  addListener(eventName: 'purchasePresentation', listener: (event: unknown) => void): Promise<PluginListenerHandle>;
+  readonly getPresentationSupport?: () => Promise<unknown>;
+}
+/** The adapter's facts helper over `native`, or undefined with an adapter from before it. */
+export declare function resolveStoreKitNativePurchasePresentation(native: StoreKitNativePresentationPlugin, adapterExports?: object): StoreKitNativePurchasePresentation | undefined;

package/dist/purchase-presentation.js

@@ -0,0 +1,9 @@
+import * as adapterCapacitor from '@mpgd/adapter-capacitor';
+/** The adapter's facts helper over `native`, or undefined with an adapter from before it. */
+export function resolveStoreKitNativePurchasePresentation(native, adapterExports = adapterCapacitor) {
+    const factory = adapterExports.createNativePurchasePresentation;
+    if (typeof factory !== 'function') {
+        return undefined;
+    }
+    return factory(native);
+}

package/dist/store-sdk.d.ts

@@ -2,8 +2,18 @@ import { type StoreSdk, type StoreSdkErrorCodeMap, type StoreSdkPurchase } from
 import type { StorePurchaseAccountBinding } from '@mpgd/platform/commerce';
 import type { CapacitorStoreKitPlugin, StoreKitTransaction } from './definitions.js';
 import { storeKitStoreSdkCapabilities } from './commerce-profile.js';
+import { type StoreKitSdkPurchasePresentation } from './purchase-presentation.js';
+export type { StoreKitSdkPurchasePresentation, StoreKitSdkPurchasePresentationEvent, } from './purchase-presentation.js';
 /** The plugin surface the commerce v2 SDK drives; `CapacitorStoreKit` by default. */
-export type CapacitorStoreKitStoreSdkPlugin = Pick<CapacitorStoreKitPlugin, 'getProducts' | 'purchase' | 'getTransactions' | 'sync' | 'finishTransaction' | 'addListener'>;
+export type CapacitorStoreKitStoreSdkPlugin = Pick<CapacitorStoreKitPlugin, 'getProducts' | 'purchase' | 'getTransactions' | 'sync' | 'finishTransaction' | 'addListener' | 'getPresentationSupport'>;
+/**
+* The code of a purchase refused because the native plugin in the app binary
+* reports no sheet facts (a web bundle newer than its native build). The
+* provider offers `presentation`, so a purchase it could not follow is not
+* sold; rebuilding the app with this package's native code, or
+* `purchasePresentation: false`, sells again. Recovery is unaffected.
+*/
+export declare const storeKitPresentationUnsupportedCode: 'STOREKIT_PRESENTATION_UNSUPPORTED';
 /** One-time kinds the App Store sells; `durable` is a StoreKit non-consumable. */
 export type StoreKitOneTimeKind = 'consumable' | 'durable';
 /** A store SKU the SDK is configured to sell and the kind the catalog declares for it. */
@@ -47,7 +57,20 @@ export interface CreateCapacitorStoreKitStoreSdkInput {
   readonly isIos?: () => boolean;
   /** Observes transactions the SDK excludes; never a grant signal. */
   readonly onDiagnostic?: (diagnostic: CapacitorStoreKitDiagnostic) => void;
+  /**
+  * Report the purchase sheet's facts (`purchasePresentation`), so the
+  * adapter's provider offers `CommerceProvider.presentation` and the game
+  * pauses until `Product.purchase()` returns rather than until a result
+  * event. Defaults to true. A native build without the facts then refuses
+  * new purchases with `STOREKIT_PRESENTATION_UNSUPPORTED`; false keeps the
+  * result-based pause of earlier releases.
+  */
+  readonly purchasePresentation?: boolean;
 }
+/** The StoreKit `StoreSdk`, with the sheet facts it declares unless turned off. */
+export type CapacitorStoreKitStoreSdk = StoreSdk & {
+  readonly purchasePresentation?: StoreKitSdkPurchasePresentation;
+};
 /**
 * Capacitor StoreKit `StoreSdk`: the commerce v2 surface over the native
 * StoreKit 2 collector (RFC B3). The App Store profile is consumable plus
@@ -67,7 +90,7 @@ export interface CreateCapacitorStoreKitStoreSdkInput {
 * or on a new device; the reconciler sends them with `intent: 'restore'` and
 * the backend's restore sharing decides (RFC "Restore sharing").
 */
-export declare function createCapacitorStoreKitStoreSdk(input: CreateCapacitorStoreKitStoreSdkInput): StoreSdk;
+export declare function createCapacitorStoreKitStoreSdk(input: CreateCapacitorStoreKitStoreSdkInput): CapacitorStoreKitStoreSdk;
 export { storeKitStoreSdkCapabilities };
 /**
 * StoreKit plugin codes merged over `defaultStoreSdkErrorCodeMap`. Codes the

package/dist/store-sdk.js

@@ -2,6 +2,15 @@ import { Capacitor } from '@capacitor/core';
 import { defaultStoreSdkErrorCodeMap, } from '@mpgd/adapter-capacitor';
 import { appStoreStoreId, storeKitStoreSdkCapabilities } from './commerce-profile.js';
 import { CapacitorStoreKit } from './plugin.js';
+import { resolveStoreKitNativePurchasePresentation, } from './purchase-presentation.js';
+/**
+ * The code of a purchase refused because the native plugin in the app binary
+ * reports no sheet facts (a web bundle newer than its native build). The
+ * provider offers `presentation`, so a purchase it could not follow is not
+ * sold; rebuilding the app with this package's native code, or
+ * `purchasePresentation: false`, sells again. Recovery is unaffected.
+ */
+export const storeKitPresentationUnsupportedCode = 'STOREKIT_PRESENTATION_UNSUPPORTED';
 /**
  * Capacitor StoreKit `StoreSdk`: the commerce v2 surface over the native
  * StoreKit 2 collector (RFC B3). The App Store profile is consumable plus
@@ -23,6 +32,10 @@ import { CapacitorStoreKit } from './plugin.js';
  */
 export function createCapacitorStoreKitStoreSdk(input) {
     const sdk = input.sdk ?? CapacitorStoreKit;
+    // Sheet facts of `purchase` calls that carry a presentation id.
+    const presentation = input.purchasePresentation === false
+        ? undefined
+        : resolveStoreKitNativePurchasePresentation(sdk);
     const isIos = input.isIos ?? (() => Capacitor.getPlatform() === 'ios');
     const onDiagnostic = input.onDiagnostic ?? (() => undefined);
     if (typeof input.getAppAccountToken !== 'function') {
@@ -259,9 +272,33 @@ export function createCapacitorStoreKitStoreSdk(input) {
     /**
      * Mirrors the native finish gate: the transaction must be listed, not
      * revoked, and bound to the session app account token. A missing list is
-     * an invalid response, not a quiet "not finished". Two exceptions for a
-     * listed, non-revoked durable, the only kind the restore read admits from
-     * another token:
+     * an invalid response, not a quiet "not finished".
+     *
+     * On a retried finish (`retry`: the caller asked to finish this purchase
+     * before, in an earlier attempt or session), a consumable the list no
+     * longer carries is already finished: StoreKit keeps a transaction in
+     * `Transaction.unfinished` until `finish()`, and a finished consumable is in
+     * neither that list nor `currentEntitlements`. That is the lost
+     * acknowledgement: an earlier finish reached StoreKit but its answer never
+     * reached the journal (the app was closed between the two), and the record
+     * would otherwise stay `finishing` forever. A first finish never reads a
+     * missing transaction that way: right after the grant the list may not
+     * carry the new transaction yet, so it stays refused and the caller retries.
+     * Nothing native is called, and an entry of that id the native side reports
+     * in any shape keeps it refused. If the transaction is listed again later
+     * (an unverifiable entry the native read skipped, or a list read before
+     * StoreKit carried it), the reconciler finishes it again without a second
+     * verify. A durable missing from the list is refused: a durable stays in
+     * `currentEntitlements` after its finish, so a missing one is revoked or
+     * unverifiable, never a lost acknowledgement. The kind of a missing
+     * transaction is the caller's `isConsumable` (the list no longer says), so a
+     * catalog that maps a durable as a consumable would be answered finished
+     * here; the SDK never admits such a transaction (`kind-mismatch`), so the
+     * reconciler cannot hold a grant for it from this SDK, and the answer
+     * neither grants nor takes anything.
+     *
+     * Two exceptions for a listed, non-revoked durable, the only kind the
+     * restore read admits from another token:
      *
      * - StoreKit already finished it (`unfinished: false`): nothing is left to
      *   finish whatever its token, so a restore shared to this player ends
@@ -279,13 +316,17 @@ export function createCapacitorStoreKitStoreSdk(input) {
      * A consumable of another token, or a transaction bound to no token, is
      * never finished here.
      */
-    const finishPermitted = async (transactionId, appAccountToken) => {
+    const finishPermitted = async (transactionId, appAccountToken, lostAcknowledgement) => {
         const response = await sdk.getTransactions();
         if (!isRecord(response) || !Array.isArray(response.transactions)) {
             throw evidenceInvalid('StoreKit returned an invalid transaction list.');
         }
-        const transaction = response.transactions.find((candidate) => isValidStoreKitTransaction(candidate) && candidate.transactionId === transactionId);
-        if (transaction === undefined || transaction.revokedAt !== undefined) {
+        const entries = response.transactions.filter((candidate) => isRecord(candidate) && candidate.transactionId === transactionId);
+        const transaction = entries.find(isValidStoreKitTransaction);
+        if (transaction === undefined) {
+            return { verdict: entries.length === 0 && lostAcknowledgement ? 'finished' : 'refused' };
+        }
+        if (transaction.revokedAt !== undefined) {
             return { verdict: 'refused' };
         }
         if (transaction.type === 'non_consumable' && transaction.unfinished === false) {
@@ -304,6 +345,7 @@ export function createCapacitorStoreKitStoreSdk(input) {
     };
     return {
         store: appStoreStoreId,
+        ...(presentation === undefined ? {} : { purchasePresentation: presentation.purchasePresentation }),
         capabilities: storeKitStoreSdkCapabilities,
         async fetchProducts(request) {
             requireIos();
@@ -326,7 +368,33 @@ export function createCapacitorStoreKitStoreSdk(input) {
             requireIos();
             const appAccountToken = readAppAccountToken(request.accountBinding);
             const expected = await assertSellable(request.sku);
-            const outcome = await sdk.purchase({ productId: request.sku, appAccountToken });
+            // Only an adapter that reads sheet facts sends an id (one from before
+            // them never does, and the purchase runs as in earlier releases).
+            const presentationId = presentation === undefined ? undefined : request.presentationId;
+            if (presentation !== undefined && presentationId !== undefined) {
+                if (!(await presentation.supported())) {
+                    throw storeKitError(storeKitPresentationUnsupportedCode, 'The app was built with a StoreKit plugin that reports no purchase sheet facts; '
+                        + "rebuild it with this package's native code.", false);
+                }
+                presentation.begin(presentationId);
+            }
+            let outcome;
+            try {
+                outcome = await sdk.purchase({
+                    productId: request.sku,
+                    appAccountToken,
+                    ...(presentationId === undefined ? {} : { presentationId }),
+                });
+            }
+            catch (error) {
+                if (presentationId !== undefined) {
+                    presentation?.answered(presentationId, error);
+                }
+                throw error;
+            }
+            if (presentationId !== undefined) {
+                presentation?.answered(presentationId, outcome);
+            }
             if (!isRecord(outcome)) {
                 throw evidenceInvalid('StoreKit returned an invalid purchase result.');
             }
@@ -409,8 +477,10 @@ export function createCapacitorStoreKitStoreSdk(input) {
             const promise = (async () => {
                 // Same match the native plugin applies: missing, revoked, unbound, or
                 // another account never reaches `transaction.finish()`, except a
-                // durable of another token (see `finishPermitted`).
-                const permitted = await finishPermitted(transactionId, appAccountToken);
+                // durable of another token (see `finishPermitted`). On a retry, a
+                // consumable that left the unfinished list is already finished (a
+                // lost acknowledgement).
+                const permitted = await finishPermitted(transactionId, appAccountToken, request.isConsumable === true && request.retry === true);
                 if (permitted.verdict !== 'finish') {
                     return { finished: permitted.verdict === 'finished' };
                 }
@@ -464,6 +534,12 @@ export function createCapacitorStoreKitStoreSdk(input) {
             if (productIds.length === 0) {
                 return 'configuration-required';
             }
+            // An adapter that reads sheet facts over a native build without them
+            // would refuse every purchase: report the store as needing a rebuild,
+            // so the shop sells nothing and no idempotency key is spent.
+            if (presentation !== undefined && presentation.followed() && !(await presentation.supported())) {
+                return 'configuration-required';
+            }
             try {
                 // Probe batch by batch until one configured product is sold; only a
                 // catalog with no sellable product at all is a configuration problem.
@@ -513,6 +589,7 @@ export const storeKitStoreSdkErrorCodeMap = Object.freeze({
     STOREKIT_FINISH_REQUIRES_GRANT: 'CONFIGURATION_REQUIRED',
     STOREKIT_EVIDENCE_INVALID: 'INVALID_RESPONSE',
     STOREKIT_TRANSACTION_UNVERIFIED: 'INVALID_RESPONSE',
+    STOREKIT_PRESENTATION_UNSUPPORTED: 'CONFIGURATION_REQUIRED',
 });
 /** The default table plus every StoreKit code; what the provider uses. */
 export const capacitorStoreKitErrorCodeMap = Object.freeze({

package/ios/Sources/CapacitorStoreKit/CapacitorStoreKitPlugin.swift

@@ -18,7 +18,8 @@ public class CapacitorStoreKitPlugin: CAPPlugin, CAPBridgedPlugin {
         CAPPluginMethod(name: "purchase", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getTransactions", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "sync", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "finishTransaction", returnType: CAPPluginReturnPromise)
+        CAPPluginMethod(name: "finishTransaction", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getPresentationSupport", returnType: CAPPluginReturnPromise)
     ]
 
     private let connection = OpenIapAppleConnection()
@@ -79,25 +80,57 @@ public class CapacitorStoreKitPlugin: CAPPlugin, CAPBridgedPlugin {
         }
     }
 
+    /// Declares the sheet facts this native code reports
+    /// (`purchasePresentation` events and the `presentation` field of
+    /// `purchase` answers). A build without this method answers
+    /// `UNIMPLEMENTED`, and the TypeScript SDK then sells nothing that would
+    /// wait for facts.
+    @objc func getPresentationSupport(_ call: CAPPluginCall) {
+        call.resolve(["purchasePresentation": MpgdPurchaseSheet.protocolVersion])
+    }
+
     @objc func purchase(_ call: CAPPluginCall) {
+        // Correlates this call's sheet facts; sent only by a TypeScript SDK
+        // that reads them. Without it the call reports no facts, as before.
+        let presentationId = call.getString("presentationId")
+        if presentationId != nil && !MpgdPurchaseSheet.isValidPresentationId(presentationId) {
+            call.reject("The presentation id is invalid.", "STOREKIT_INVALID_PURCHASE", nil,
+                        ["presentation": MpgdPurchaseSheet.Fact.notStarted.rawValue])
+            return
+        }
+        let sheet = presentationId.map { id in
+            MpgdPurchaseSheet(presentationId: id) { [weak self] id, fact in
+                self?.notifyPresentation(id, fact)
+            }
+        }
         guard let productId = call.getString("productId"),
               StoreKitTransactionPolicy.isValidProductId(productId),
               let accountToken = StoreKitTransactionPolicy.normalizedAccountToken(
                 call.getString("appAccountToken"), allowNil: true) else {
-            call.reject("A product ID and app account token are required.", "STOREKIT_INVALID_PURCHASE")
+            sheet?.end()
+            call.reject("A product ID and app account token are required.", "STOREKIT_INVALID_PURCHASE",
+                        nil, Self.presentationData(sheet))
+            return
+        }
+        if let message = connection.providerError {
+            sheet?.end()
+            call.reject(message, "STOREKIT_CONFIGURATION_ERROR", nil, Self.presentationData(sheet))
             return
         }
-        guard providerReady(call) else { return }
         Task { @MainActor [module] in
             do {
                 let result = try await module.fetchProducts(ProductRequest(skus: [productId], type: .inApp))
                 guard let product = Self.iosProducts(result).first(where: { $0.id == productId }),
                       MpgdOneTimeType(productType: product.typeIOS) != nil else {
-                    call.reject("The one-time product is unavailable.", "STOREKIT_PRODUCT_UNAVAILABLE")
+                    sheet?.end()
+                    call.reject("The one-time product is unavailable.", "STOREKIT_PRODUCT_UNAVAILABLE",
+                                nil, Self.presentationData(sheet))
                     return
                 }
             } catch {
-                call.reject("StoreKit product lookup failed.", "STOREKIT_PRODUCT_LOOKUP_FAILED", error)
+                sheet?.end()
+                call.reject("StoreKit product lookup failed.", "STOREKIT_PRODUCT_LOOKUP_FAILED", error,
+                            Self.presentationData(sheet))
                 return
             }
             let request = RequestPurchaseProps(
@@ -109,40 +142,68 @@ public class CapacitorStoreKitPlugin: CAPPlugin, CAPBridgedPlugin {
                 ))),
                 type: .inApp
             )
+            // `open` right before OpenIAP calls `Product.purchase()`, which
+            // presents the sheet; `closed` once that call returned or threw,
+            // before the answer, which carries the same fact.
+            sheet?.open()
             do {
                 let outcome = try await module.requestPurchase(request)
+                sheet?.end()
                 guard case .purchase(let purchased?) = outcome,
                       case .purchaseIos(let ios) = purchased,
                       let transaction = StoreKitTransactionPolicy.transaction(from: ios),
                       StoreKitTransactionPolicy.matchesPurchaseRequest(
                         transaction, productId: productId, appAccountToken: accountToken) else {
                     call.reject("StoreKit transaction failed verification or account binding.",
-                                "STOREKIT_TRANSACTION_UNVERIFIED")
+                                "STOREKIT_TRANSACTION_UNVERIFIED", nil, Self.presentationData(sheet))
                     return
                 }
-                call.resolve([
+                call.resolve(Self.withPresentation([
                     "status": "purchased",
                     "transaction": StoreKitTransactionPolicy.payload(transaction)
-                ])
+                ], sheet))
             } catch let error as PurchaseError {
+                sheet?.end()
                 switch StoreKitTransactionPolicy.purchaseFailure(error.code) {
                 case .cancelled:
-                    call.resolve(["status": "cancelled"])
+                    call.resolve(Self.withPresentation(["status": "cancelled"], sheet))
                 case .pending:
                     // Ask to Buy: the approved transaction arrives through
-                    // `transactionUpdated` or `getTransactions` later.
-                    call.resolve(["status": "pending"])
+                    // `transactionUpdated` or `getTransactions` later. The
+                    // sheet itself is done.
+                    call.resolve(Self.withPresentation(["status": "pending"], sheet))
                 case .rejected(let code, let message):
-                    call.reject(message, code, error)
+                    call.reject(message, code, error, Self.presentationData(sheet))
                 }
             } catch {
+                sheet?.end()
                 // The purchase sheet may have completed before an error reached us.
                 call.reject("StoreKit purchase result is uncertain; requery transactions.",
-                            "STOREKIT_PURCHASE_UNCERTAIN", error)
+                            "STOREKIT_PURCHASE_UNCERTAIN", error, Self.presentationData(sheet))
             }
         }
     }
 
+    /// Retained until a listener consumes it; the random id keeps a fact of
+    /// an earlier web session from matching a new call.
+    private func notifyPresentation(_ presentationId: String, _ fact: MpgdPurchaseSheet.Fact) {
+        notifyListeners("purchasePresentation",
+                        data: ["presentationId": presentationId, "state": fact.rawValue],
+                        retainUntilConsumed: true)
+    }
+
+    private static func presentationData(_ sheet: MpgdPurchaseSheet?) -> [String: Any]? {
+        guard let sheet else { return nil }
+        return ["presentation": sheet.answer]
+    }
+
+    private static func withPresentation(_ answer: [String: Any], _ sheet: MpgdPurchaseSheet?) -> [String: Any] {
+        guard let sheet else { return answer }
+        var answered = answer
+        answered["presentation"] = sheet.answer
+        return answered
+    }
+
     @objc func getTransactions(_ call: CAPPluginCall) {
         guard providerReady(call) else { return }
         Task {

package/ios/Sources/MpgdStoreKitBridge/PurchaseSheet.swift

@@ -0,0 +1,62 @@
+import Foundation
+
+/// The purchase sheet facts of one `purchase` call that sent a presentation
+/// id. The plugin reports `open` right before OpenIAP calls
+/// `Product.purchase()` and `closed` when that returns or throws; a call it
+/// refuses before then is `not-started`. Each sheet reports at most one
+/// `open` and exactly one terminal fact, whatever order the plugin calls
+/// these in. Apple documents that `Product.purchase()` presents the
+/// confirmation sheet, not that it returns only once the sheet is dismissed,
+/// so `closed` is "the purchase call ended" until device testing proves more.
+public final class MpgdPurchaseSheet {
+    public enum Fact: String, Sendable {
+        case open
+        case closed
+        case notStarted = "not-started"
+    }
+
+    /// The facts protocol version `getPresentationSupport` declares.
+    public static let protocolVersion = 1
+
+    public let presentationId: String
+    private let emit: (String, Fact) -> Void
+    private var opened = false
+    public private(set) var ended: Fact?
+
+    public init(presentationId: String, emit: @escaping (String, Fact) -> Void) {
+        self.presentationId = presentationId
+        self.emit = emit
+    }
+
+    /// The `presentation` value of the call's answer: the terminal fact, or
+    /// `open` while the sheet is up, or `requested` before anything happened.
+    public var answer: String {
+        if let ended { return ended.rawValue }
+        return opened ? Fact.open.rawValue : "requested"
+    }
+
+    public func open() {
+        guard ended == nil, !opened else { return }
+        opened = true
+        emit(presentationId, .open)
+    }
+
+    /// The purchase call ended: `closed` after `open`, otherwise `not-started`.
+    public func end() {
+        guard ended == nil else { return }
+        let fact: Fact = opened ? .closed : .notStarted
+        ended = fact
+        emit(presentationId, fact)
+    }
+
+    /// 1-64 characters of `[A-Za-z0-9-]`, as the TypeScript SDK sends (a UUID).
+    public static func isValidPresentationId(_ value: String?) -> Bool {
+        guard let value, !value.isEmpty, value.count <= 64 else { return false }
+        return value.unicodeScalars.allSatisfy { scalar in
+            (scalar.value >= 0x30 && scalar.value <= 0x39)
+                || (scalar.value >= 0x41 && scalar.value <= 0x5A)
+                || (scalar.value >= 0x61 && scalar.value <= 0x7A)
+                || scalar == "-"
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/capacitor-storekit",
-  "version": "0.4.5",
+  "version": "0.6.0",
   "description": "Opt-in StoreKit 2 one-time purchase collector and commerce v2 provider for mpgd Capacitor games.",
   "license": "MIT",
   "repository": {
@@ -38,18 +38,18 @@
   ],
   "peerDependencies": {
     "@capacitor/core": "^8.5.1",
-    "@mpgd/adapter-capacitor": "^0.16.0",
-    "@mpgd/bridge": "^0.16.0",
-    "@mpgd/platform": "^0.32.0"
+    "@mpgd/adapter-capacitor": "^0.18.0",
+    "@mpgd/bridge": "^0.18.0",
+    "@mpgd/platform": "^0.34.0"
   },
   "devDependencies": {
     "@capacitor/core": "8.5.2",
-    "ttsc": "0.32.1",
+    "ttsc": "0.34.2",
     "typescript": "7.0.2",
-    "@mpgd/adapter-capacitor": "0.16.3",
-    "@mpgd/bridge": "0.16.4",
-    "@mpgd/game-services": "0.30.5",
-    "@mpgd/platform": "0.32.0"
+    "@mpgd/adapter-capacitor": "0.18.0",
+    "@mpgd/bridge": "0.18.0",
+    "@mpgd/platform": "0.34.0",
+    "@mpgd/game-services": "0.32.0"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -59,6 +59,6 @@
   "scripts": {
     "check": "ttsc --noEmit",
     "lint": "ttsc --noEmit",
-    "test": "cd ../.. && node tools/run-ttsx.mjs --project native-plugins/capacitor-storekit/tsconfig.json native-plugins/capacitor-storekit/src/store-sdk.test.ts && node tools/run-ttsx.mjs --project native-plugins/capacitor-storekit/tsconfig.json native-plugins/capacitor-storekit/src/commerce-profile.test.ts && node tools/run-ttsx.mjs --project native-plugins/capacitor-storekit/tsconfig.json native-plugins/capacitor-storekit/src/commerce-provider.test.ts && node tools/run-ttsx.mjs --project native-plugins/capacitor-storekit/tsconfig.json native-plugins/capacitor-storekit/src/commerce-provider.conformance.test.ts && node tools/run-ttsx.mjs --project native-plugins/capacitor-storekit/tsconfig.json native-plugins/capacitor-storekit/src/commerce-reconciler-storekit-smoke.test.ts && node tools/run-ttsx.mjs --project native-plugins/capacitor-storekit/tsconfig.json native-plugins/capacitor-storekit/src/openiap-engine-swap.test.ts && node tools/run-ttsx.mjs --project native-plugins/capacitor-storekit/tsconfig.json native-plugins/capacitor-storekit/src/commerce-restore-reinstall.test.ts"
+    "test": "cd ../.. && node tools/run-ttsx.mjs --project native-plugins/capacitor-storekit/tsconfig.json native-plugins/capacitor-storekit/src/store-sdk.test.ts && node tools/run-ttsx.mjs --project native-plugins/capacitor-storekit/tsconfig.json native-plugins/capacitor-storekit/src/commerce-profile.test.ts && node tools/run-ttsx.mjs --project native-plugins/capacitor-storekit/tsconfig.json native-plugins/capacitor-storekit/src/commerce-provider.test.ts && node tools/run-ttsx.mjs --project native-plugins/capacitor-storekit/tsconfig.json native-plugins/capacitor-storekit/src/commerce-provider.conformance.test.ts && node tools/run-ttsx.mjs --project native-plugins/capacitor-storekit/tsconfig.json native-plugins/capacitor-storekit/src/commerce-reconciler-storekit-smoke.test.ts && node tools/run-ttsx.mjs --project native-plugins/capacitor-storekit/tsconfig.json native-plugins/capacitor-storekit/src/openiap-engine-swap.test.ts && node tools/run-ttsx.mjs --project native-plugins/capacitor-storekit/tsconfig.json native-plugins/capacitor-storekit/src/commerce-restore-reinstall.test.ts && node tools/run-ttsx.mjs --project native-plugins/capacitor-storekit/tsconfig.json native-plugins/capacitor-storekit/src/purchase-presentation.test.ts"
   }
 }