@mpgd/adapter-capacitor 0.16.3 → 0.18.0

package/dist/purchase-presentation.js

@@ -0,0 +1,170 @@
+/**
+ * Upper bound on how long one store sheet counts as open (or possibly open)
+ * without a native `closed` fact. Past it the provider reports `closed` with
+ * reason `timeout`, so a lost native observation can pause the game, but
+ * never forever. It matches the purchase flow timeout of the OpenIAP Google
+ * core (15 minutes).
+ */
+export const purchasePresentationTimeoutMs = 15 * 60_000;
+/**
+ * Sheet facts by presentation id from the plugin's `purchasePresentation`
+ * events and the `presentation` field of its `purchase` answers, whichever
+ * arrives first; each call gets at most one `open` and one terminal fact.
+ * A `requested` answer is reported as `unknown`: the sheet may still come,
+ * so the provider keeps the call waiting for the native `open`, `closed`, or
+ * `not-started` instead of reading the answer as a sheet that never opened
+ * or inventing one that did. The native listener is attached with the first
+ * subscriber and removed with the last.
+ *
+ * Exported for the store plugins, which peer on this package. A plugin reads
+ * it through the module namespace, so with an adapter from before it the
+ * plugin declares no facts (and that adapter never asks for them).
+ */
+export function createNativePurchasePresentation(native) {
+    const listeners = new Set();
+    const sheets = new Map();
+    let handle;
+    let generation = 0;
+    let support;
+    const report = (presentationId, state, reason) => {
+        const current = sheets.get(presentationId);
+        if (current === undefined || current === state || (state === 'unknown' && current === 'open')) {
+            return;
+        }
+        if (state === 'open' || state === 'unknown') {
+            sheets.set(presentationId, state);
+        }
+        else {
+            sheets.delete(presentationId);
+        }
+        const event = {
+            presentationId,
+            state,
+            ...(reason === undefined ? {} : { reason }),
+        };
+        for (const entry of [...listeners]) {
+            if (!listeners.has(entry)) {
+                continue;
+            }
+            // One failing listener must not keep a later one (the commerce
+            // provider) from its `closed` fact.
+            try {
+                entry.listener(event);
+            }
+            catch (error) {
+                console.warn('A purchase presentation listener failed.', error);
+            }
+        }
+    };
+    const onNativeFact = (event) => {
+        if (!isRecord(event) || typeof event.presentationId !== 'string') {
+            return;
+        }
+        const { state, reason } = event;
+        if (state === 'open' || state === 'closed' || state === 'not-started') {
+            report(event.presentationId, state, state === 'closed' && (reason === 'interrupted' || reason === 'timeout')
+                ? reason
+                : undefined);
+        }
+    };
+    const attach = () => {
+        if (handle !== undefined) {
+            return;
+        }
+        const attached = generation;
+        let added;
+        try {
+            added = native.addListener('purchasePresentation', (event) => {
+                if (attached === generation) {
+                    onNativeFact(event);
+                }
+            });
+        }
+        catch {
+            return;
+        }
+        handle = added;
+        added.catch(() => {
+            if (handle === added) {
+                handle = undefined;
+            }
+        });
+    };
+    const detach = () => {
+        const current = handle;
+        if (current === undefined) {
+            return;
+        }
+        handle = undefined;
+        generation += 1;
+        current.then((resolved) => resolved.remove()).catch(() => undefined);
+    };
+    return {
+        purchasePresentation: {
+            subscribe(listener) {
+                const entry = { listener };
+                listeners.add(entry);
+                attach();
+                return () => {
+                    if (listeners.delete(entry) && listeners.size === 0) {
+                        detach();
+                    }
+                };
+            },
+        },
+        followed() {
+            return listeners.size > 0;
+        },
+        supported() {
+            if (support !== undefined) {
+                return support;
+            }
+            const check = native.getPresentationSupport;
+            if (typeof check !== 'function') {
+                return Promise.resolve(false);
+            }
+            const attempt = Promise.resolve()
+                .then(() => check.call(native))
+                .then((answer) => isRecord(answer)
+                && typeof answer.purchasePresentation === 'number'
+                && answer.purchasePresentation >= 1, (error) => {
+                if (!isRecord(error) || error.code !== 'UNIMPLEMENTED') {
+                    support = undefined;
+                }
+                return false;
+            });
+            support = attempt;
+            return attempt;
+        },
+        begin(presentationId) {
+            sheets.set(presentationId, 'requested');
+        },
+        answered(presentationId, answerOrError) {
+            const presentation = answeredPresentation(answerOrError);
+            if (presentation === 'open' || presentation === 'closed' || presentation === 'not-started') {
+                report(presentationId, presentation);
+            }
+            else if (presentation === 'requested') {
+                report(presentationId, 'unknown');
+            }
+            else if (sheets.get(presentationId) === 'requested') {
+                // No sheet state from native code that declared facts: nothing was
+                // seen opening, which the provider reads as not-started.
+                sheets.delete(presentationId);
+            }
+        },
+    };
+}
+/** The `presentation` of a `purchase` answer or of a rejection's `data`. */
+function answeredPresentation(answer) {
+    if (!isRecord(answer)) {
+        return undefined;
+    }
+    if ('presentation' in answer) {
+        return answer.presentation;
+    }
+    return isRecord(answer.data) ? answer.data.presentation : undefined;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

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

@@ -1,5 +1,5 @@
-import type { PlatformEvidenceEnvelope } from '@mpgd/platform';
-import { type CommerceAuthorityCapabilities, type CommerceCatalogCapabilities, type CommerceErrorCode, type CommerceLifecycleCapabilities, type CommerceLogicalProductId, type CommerceProvider, type CommercePurchaseCapabilities, type PurchaseKind, type StoreId, type StorePurchaseAccountBinding } from '@mpgd/platform/commerce';
+import { type PlatformEvidenceEnvelope } from '@mpgd/platform';
+import { type CommerceAuthorityCapabilities, type CommerceCatalogCapabilities, type CommerceErrorCode, type CommerceLifecycleCapabilities, type CommerceLogicalProductId, type CommerceProvider, type CommercePurchaseCapabilities, type PurchaseKind, type PurchaseSource, type StoreId, type StorePurchaseAccountBinding } from '@mpgd/platform/commerce';
 import { type StoreSdk, type StoreSdkErrorCodeMap, type StoreSdkPurchase } from './store-sdk.js';
 /** One catalog product sold through the store under `storeSku`. */
 export interface StoreCommerceProductMapping {
@@ -15,6 +15,41 @@ export interface StoreCommerceCapabilityOverrides {
   readonly catalog?: Partial<CommerceCatalogCapabilities>;
   readonly lifecycle?: Partial<CommerceLifecycleCapabilities>;
 }
+/** 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. A refusal becomes a `failed` purchase result with
+* `ITEM_UNAVAILABLE` and `storeCode` (default `PURCHASES_PAUSED`), returned as
+* data so the reason survives the bridge; `retryable` defaults to false.
+*/
+export type StorePurchaseGateDecision = {
+  readonly allowed: true;
+} | {
+  readonly allowed: false;
+  readonly storeCode?: string;
+  readonly message?: string;
+  readonly retryable?: boolean;
+};
+/**
+* The game's sales switch: asked before a NEW purchase opens the store UI,
+* after the product, availability, and kind checks and before the account
+* binding. Recovery, restore, finishing, events, and `getAvailablePurchases`
+* never consult it, so purchases already paid for keep reconciling while new
+* sales are refused. A gate that throws refuses the purchase (fail closed).
+*/
+export type StorePurchaseGate = (request: StorePurchaseGateRequest) => StorePurchaseGateDecision | Promise<StorePurchaseGateDecision>;
+/** `storeCode` of a purchase the gate refused without naming its own. */
+export declare const purchasesPausedStoreCode: 'PURCHASES_PAUSED';
+/** `storeCode` of a purchase refused because the gate threw or answered nonsense. */
+export declare const purchaseGateFailedStoreCode: 'PURCHASE_GATE_FAILED';
+/** `storeCode` of a purchase refused because the account binding lookup threw. */
+export declare const accountBindingLookupFailedStoreCode: 'ACCOUNT_BINDING_LOOKUP_FAILED';
 export interface CreateStoreCommerceProviderInput {
   readonly sdk: StoreSdk;
   /** Defaults to `sdk.store`. */
@@ -27,23 +62,51 @@ export interface CreateStoreCommerceProviderInput {
   * and SKU; a store provider replaces it to match its backend verifier.
   */
   readonly evidencePayload?: (purchase: StoreSdkPurchase) => PlatformEvidenceEnvelope['payload'];
-  /** Resolves the player's store account binding before a purchase opens. */
+  /**
+  * Resolves the player's store account binding before a purchase opens. A
+  * failure (thrown, or no binding while `authority.accountBinding` is
+  * `required`) is answered as a `failed` purchase result, not thrown, so its
+  * `storeCode` survives the bridge.
+  */
   readonly accountBinding?: () => Promise<StorePurchaseAccountBinding | undefined>;
+  /** Optional sales switch for new purchases; see `StorePurchaseGate`. */
+  readonly purchaseGate?: StorePurchaseGate;
   readonly capabilities?: StoreCommerceCapabilityOverrides;
   readonly authority: CommerceAuthorityCapabilities;
   /** Per-store error codes merged over `defaultStoreSdkErrorCodeMap`. */
   readonly mapError?: StoreSdkErrorCodeMap;
 }
 export interface StoreCommerceProvider extends CommerceProvider {
-  /** Detaches the SDK listeners; buffered events are dropped. */
+  /**
+  * Detaches the SDK listeners; buffered events are dropped. A store sheet
+  * still open gets its `closed` fact (reason `disposed`) first.
+  */
   dispose(): void;
 }
 /**
+* Upper bound on one purchase gate answer. The gate runs while the gateway
+* holds the purchase's external activity, so a gate that never settles would
+* keep the game paused; past this bound the purchase is refused
+* (`PURCHASE_GATE_FAILED`, retryable) and a late answer is ignored.
+*/
+export declare const purchaseGateTimeoutMs = 3000;
+/**
 * `CommerceProvider` over an in-process `StoreSdk`. The provider maps logical
 * ids to store SKUs both ways, composes `CommerceCapabilities` from the SDK
 * declaration, builds `StorePurchase` evidence, buffers SDK events until the
 * first subscriber, and normalizes every SDK failure into a `CommerceError`.
 * It never grants and never sets `settlement`; the backend ledger decides.
+*
+* Over an SDK that declares `purchasePresentation`, the provider offers
+* `presentation` and answers every `requestPurchase` call with facts keyed
+* by its idempotency key: `not-started`, delivered before the call settles,
+* for any call that opened no sheet (a purchase gate or account binding
+* refusal, an unavailable store, a throw, or the SDK's own `not-started`);
+* otherwise `open` and exactly one `closed` when the SDK reports the sheet
+* gone, or after `purchasePresentationTimeoutMs` (reason `timeout`), or on
+* `dispose` (reason `disposed`). A result, a pending purchase, or a purchase
+* event never closes a sheet. An SDK without the declaration leaves the
+* provider without `presentation`, as before.
 */
 export declare function createStoreCommerceProvider(input: CreateStoreCommerceProviderInput): StoreCommerceProvider;
 /**

package/dist/store-commerce-provider.js

@@ -1,6 +1,21 @@
+import { createPurchasePresentationChannel, isPurchasePresentationReason, } from '@mpgd/platform';
 import { assertFinishTransactionInput, assertFinishTransactionResult, assertRequestPurchaseSupported, assertStoreProduct, assertStorePurchase, CommerceError, createCommerceEventBuffer, } from '@mpgd/platform/commerce';
+import { purchasePresentationTimeoutMs, } from './purchase-presentation.js';
 import { defaultStoreSdkErrorCodeMap, normalizeStoreSdkError, } from './store-sdk.js';
+/** `storeCode` of a purchase the gate refused without naming its own. */
+export const purchasesPausedStoreCode = 'PURCHASES_PAUSED';
+/** `storeCode` of a purchase refused because the gate threw or answered nonsense. */
+export const purchaseGateFailedStoreCode = 'PURCHASE_GATE_FAILED';
+/** `storeCode` of a purchase refused because the account binding lookup threw. */
+export const accountBindingLookupFailedStoreCode = 'ACCOUNT_BINDING_LOOKUP_FAILED';
 const availabilityTimeoutMs = 3_000;
+/**
+ * Upper bound on one purchase gate answer. The gate runs while the gateway
+ * holds the purchase's external activity, so a gate that never settles would
+ * keep the game paused; past this bound the purchase is refused
+ * (`PURCHASE_GATE_FAILED`, retryable) and a late answer is ignored.
+ */
+export const purchaseGateTimeoutMs = 3_000;
 const availabilitySet = new Set([
     'unsupported',
     'configuration-required',
@@ -14,6 +29,17 @@ const availabilitySet = new Set([
  * declaration, builds `StorePurchase` evidence, buffers SDK events until the
  * first subscriber, and normalizes every SDK failure into a `CommerceError`.
  * It never grants and never sets `settlement`; the backend ledger decides.
+ *
+ * Over an SDK that declares `purchasePresentation`, the provider offers
+ * `presentation` and answers every `requestPurchase` call with facts keyed
+ * by its idempotency key: `not-started`, delivered before the call settles,
+ * for any call that opened no sheet (a purchase gate or account binding
+ * refusal, an unavailable store, a throw, or the SDK's own `not-started`);
+ * otherwise `open` and exactly one `closed` when the SDK reports the sheet
+ * gone, or after `purchasePresentationTimeoutMs` (reason `timeout`), or on
+ * `dispose` (reason `disposed`). A result, a pending purchase, or a purchase
+ * event never closes a sheet. An SDK without the declaration leaves the
+ * provider without `presentation`, as before.
  */
 export function createStoreCommerceProvider(input) {
     const { sdk } = input;
@@ -134,6 +160,77 @@ export function createStoreCommerceProvider(input) {
             });
         }),
     ];
+    // Presentation: SDK facts by presentation id, published by idempotency key.
+    const sdkPresentation = sdk.purchasePresentation;
+    const presentation = sdkPresentation === undefined
+        ? undefined
+        : createPurchasePresentationChannel({
+            onListenerError: (error) => {
+                // A failing listener must not keep a `closed` fact from the others.
+                console.warn('A purchase presentation listener failed.', error);
+            },
+        });
+    const flights = new Map();
+    let disposed = false;
+    const endFlight = (flight, state, reason) => {
+        if (flights.get(flight.presentationId) !== flight) {
+            return;
+        }
+        flights.delete(flight.presentationId);
+        if (flight.timer !== undefined) {
+            clearTimeout(flight.timer);
+        }
+        // A sheet that opened can only close; `not-started` after `open` would
+        // tell a consumer the sheet never showed.
+        const fact = flight.open ? 'closed' : state;
+        presentation?.publish({
+            idempotencyKey: flight.idempotencyKey,
+            state: fact,
+            ...(reason === undefined || fact !== 'closed' ? {} : { reason }),
+        });
+    };
+    const onPresentationFact = (event) => {
+        if (!isRecord(event) || typeof event.presentationId !== 'string') {
+            return;
+        }
+        const flight = flights.get(event.presentationId);
+        if (flight === undefined) {
+            // Another call's, an already ended call's, or an earlier session's fact.
+            return;
+        }
+        const armSafetyTimeout = () => {
+            flight.timer ??= setTimeout(() => endFlight(flight, 'closed', 'timeout'), purchasePresentationTimeoutMs);
+        };
+        switch (event.state) {
+            case 'open':
+                if (!flight.open) {
+                    flight.open = true;
+                    presentation?.publish({ idempotencyKey: flight.idempotencyKey, state: 'open' });
+                    armSafetyTimeout();
+                }
+                return;
+            case 'unknown':
+                // The sheet may still open: the call's answer does not end it.
+                if (!flight.open && !flight.pending) {
+                    flight.pending = true;
+                    presentation?.publish({ idempotencyKey: flight.idempotencyKey, state: 'unknown' });
+                    armSafetyTimeout();
+                }
+                return;
+            case 'closed':
+                endFlight(flight, 'closed', isPurchasePresentationReason(event.reason) ? event.reason : undefined);
+                return;
+            case 'not-started':
+                endFlight(flight, 'not-started');
+                return;
+            default:
+                // An unknown fact proves nothing; the safety timeout still bounds the sheet.
+                return;
+        }
+    };
+    if (sdkPresentation !== undefined) {
+        detachers.push(sdkPresentation.subscribe(onPresentationFact));
+    }
     const getAvailability = sdk.getAvailability;
     const readAvailability = async () => {
         if (getAvailability === undefined) {
@@ -172,10 +269,91 @@ export function createStoreCommerceProvider(input) {
         authority: { ...input.authority },
         availability: await readAvailability(),
     });
+    const requestStorePurchase = async (request, presentationId) => {
+        const mapping = byLogicalId.get(request.logicalId);
+        if (mapping === undefined) {
+            throw new CommerceError('ITEM_UNAVAILABLE', {
+                message: `Store ${store} does not sell ${request.logicalId}.`,
+            });
+        }
+        const capabilities = await getCapabilities();
+        assertAvailable(capabilities.availability, store);
+        assertRequestPurchaseSupported(capabilities, request, mapping.kind);
+        // Pre-launch refusals below are data, not throws: a `failed` result
+        // keeps its `storeCode` across the bridge, a thrown error does not.
+        if (input.purchaseGate !== undefined) {
+            const refusal = await askPurchaseGate(input.purchaseGate, {
+                store,
+                logicalId: mapping.logicalId,
+                storeSku: mapping.storeSku,
+                kind: mapping.kind,
+                source: request.source,
+            });
+            if (refusal !== undefined) {
+                return { outcome: 'failed', error: refusal };
+            }
+        }
+        let accountBinding;
+        try {
+            accountBinding = await input.accountBinding?.();
+        }
+        catch (error) {
+            return { outcome: 'failed', error: accountBindingFailure(error, store) };
+        }
+        if (input.authority.accountBinding === 'required' && accountBinding === undefined) {
+            return {
+                outcome: 'failed',
+                error: new CommerceError('ACCOUNT_BINDING_REQUIRED', {
+                    message: `Store ${store} requires an account binding before a purchase.`,
+                }).toCommerceErrorInfo(),
+            };
+        }
+        const offerId = request.offerId ?? mapping.offerId;
+        if (disposed) {
+            // Its listeners are gone: a sheet opened now could never be reported.
+            throw new CommerceError('NOT_PREPARED', {
+                message: `Store ${store} was disposed before the purchase opened.`,
+            });
+        }
+        const flight = presentationId === undefined ? undefined : flights.get(presentationId);
+        if (flight !== undefined) {
+            flight.launched = true;
+        }
+        let result;
+        try {
+            result = await sdk.requestPurchase({
+                sku: mapping.storeSku,
+                ...(offerId === undefined ? {} : { offerId }),
+                ...(request.quantity === undefined ? {} : { quantity: request.quantity }),
+                ...(accountBinding === undefined ? {} : { accountBinding }),
+                ...(presentationId === undefined ? {} : { presentationId }),
+            });
+        }
+        catch (error) {
+            return failureOutcome(undefined, normalize(error).toCommerceErrorInfo());
+        }
+        if (!isRecord(result)) {
+            throw invalidRequestResult(store);
+        }
+        switch (result.outcome) {
+            case 'launched':
+                return { outcome: 'launched' };
+            case 'purchased':
+                return { outcome: 'purchased', purchase: toStorePurchase(result.purchase) };
+            case 'cancelled':
+            case 'failed':
+                return failureOutcome(result.outcome, normalize(result.error).toCommerceErrorInfo());
+            default:
+                throw invalidRequestResult(store);
+        }
+    };
     const finishTransaction = sdk.finishTransaction;
     const restorePurchases = sdk.restorePurchases;
     const provider = {
         store,
+        ...(presentation === undefined ? {} : { presentation: presentation.presentation }),
+        // `retry` is forwarded to the SDK below.
+        ...(finishTransaction === undefined ? {} : { acceptsFinishRetry: true }),
         getCapabilities,
         async fetchProducts(request = {}) {
             const type = request.type ?? 'all';
@@ -236,47 +414,41 @@ export function createStoreCommerceProvider(input) {
             return products;
         },
         async requestPurchase(request) {
-            const mapping = byLogicalId.get(request.logicalId);
-            if (mapping === undefined) {
-                throw new CommerceError('ITEM_UNAVAILABLE', {
-                    message: `Store ${store} does not sell ${request.logicalId}.`,
-                });
+            if (presentation === undefined) {
+                return requestStorePurchase(request, undefined);
             }
-            const capabilities = await getCapabilities();
-            assertAvailable(capabilities.availability, store);
-            assertRequestPurchaseSupported(capabilities, request, mapping.kind);
-            const accountBinding = await input.accountBinding?.();
-            if (input.authority.accountBinding === 'required' && accountBinding === undefined) {
-                throw new CommerceError('ACCOUNT_BINDING_REQUIRED', {
-                    message: `Store ${store} requires an account binding before a purchase.`,
-                });
+            if ([...flights.values()].some((live) => live.idempotencyKey === request.idempotencyKey)) {
+                // Facts are keyed by idempotency key: a second sheet for a key whose
+                // sheet is still in flight could not be told apart from the first,
+                // and its end would end the first one's pause. Answered as data and
+                // without a fact; the first call's facts stay the key's truth.
+                return {
+                    outcome: 'failed',
+                    error: new CommerceError('IN_PROGRESS', {
+                        message: `A purchase for ${request.idempotencyKey} is still in flight.`,
+                    }).toCommerceErrorInfo(),
+                };
             }
-            const offerId = request.offerId ?? mapping.offerId;
-            let result;
+            const flight = {
+                idempotencyKey: request.idempotencyKey,
+                presentationId: crypto.randomUUID(),
+                open: false,
+                pending: false,
+                launched: false,
+            };
+            flights.set(flight.presentationId, flight);
             try {
-                result = await sdk.requestPurchase({
-                    sku: mapping.storeSku,
-                    ...(offerId === undefined ? {} : { offerId }),
-                    ...(request.quantity === undefined ? {} : { quantity: request.quantity }),
-                    ...(accountBinding === undefined ? {} : { accountBinding }),
-                });
+                return await requestStorePurchase(request, flight.presentationId);
             }
-            catch (error) {
-                return failureOutcome(undefined, normalize(error).toCommerceErrorInfo());
-            }
-            if (!isRecord(result)) {
-                throw invalidRequestResult(store);
-            }
-            switch (result.outcome) {
-                case 'launched':
-                    return { outcome: 'launched' };
-                case 'purchased':
-                    return { outcome: 'purchased', purchase: toStorePurchase(result.purchase) };
-                case 'cancelled':
-                case 'failed':
-                    return failureOutcome(result.outcome, normalize(result.error).toCommerceErrorInfo());
-                default:
-                    throw invalidRequestResult(store);
+            finally {
+                // Settled without an `open` fact: no sheet opened. Published before
+                // the caller sees the answer, so a consumer that frees a retryable
+                // refusal's key (the reconciler) reads it with the result. A call
+                // whose SDK reported `unknown` keeps waiting for the native verdict
+                // (bounded by the safety timeout, which reports `closed`).
+                if (!flight.open && !flight.pending) {
+                    endFlight(flight, 'not-started');
+                }
             }
         },
         async getAvailablePurchases(request = {}) {
@@ -322,6 +494,7 @@ export function createStoreCommerceProvider(input) {
                         transactionId: finish.transactionId,
                         isConsumable: finish.isConsumable,
                         ledgerEntryId: finish.ledgerEntryId,
+                        ...(finish.retry === true ? { retry: true } : {}),
                     });
                 }
                 catch (error) {
@@ -361,6 +534,15 @@ export function createStoreCommerceProvider(input) {
             for (const detach of detachers.splice(0, detachers.length)) {
                 detach();
             }
+            // No SDK fact arrives any more, and the listeners go below: every call
+            // in flight gets its terminal fact now. A sheet that is (or may be)
+            // up is reported closed; a call still before its sheet is not-started,
+            // and it will not open one.
+            disposed = true;
+            for (const flight of [...flights.values()]) {
+                endFlight(flight, flight.open || flight.pending || flight.launched ? 'closed' : 'not-started', 'disposed');
+            }
+            presentation?.clear();
             listeners.clear();
             buffer.drain(() => undefined);
         },
@@ -387,6 +569,88 @@ function defaultEvidencePayload(purchase) {
             : { originalTransactionId: purchase.originalTransactionId }),
     };
 }
+/**
+ * Codes a pre-launch hook (the purchase gate or the account binding) must not
+ * report: they claim a store sheet was shown or may hold a purchase, and
+ * nothing was launched. A hook that throws one is reported under the hook's
+ * own refusal code instead.
+ */
+function misleadsBeforeLaunch(code) {
+    return recoverableErrorCodes.has(code) || code === 'USER_CANCELLED';
+}
+/**
+ * Asks the gate about one new purchase, bounded by `purchaseGateTimeoutMs`;
+ * undefined means allowed. A refusal
+ * (`allowed: false`) is the gate's definitive answer: `PURCHASES_PAUSED` or
+ * its own code, retryable only when it says so. A gate that could not answer
+ * (it threw, timed out, or returned anything malformed) is `PURCHASE_GATE_FAILED`, and
+ * always retryable: the sales flag is unknown, not closed, so asking again
+ * may succeed. A thrown `CommerceError` keeps its code unless the code
+ * claims a launched or cancelled sheet.
+ */
+async function askPurchaseGate(gate, request) {
+    const gateFailed = (message, cause) => new CommerceError('ITEM_UNAVAILABLE', {
+        message,
+        storeCode: purchaseGateFailedStoreCode,
+        retryable: true,
+        ...(cause === undefined ? {} : { cause }),
+    }).toCommerceErrorInfo();
+    let decision;
+    let timer;
+    try {
+        decision = await Promise.race([
+            Promise.resolve().then(() => gate(request)),
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => reject(new Error(`The purchase gate did not answer within ${purchaseGateTimeoutMs} ms.`)), purchaseGateTimeoutMs);
+            }),
+        ]);
+    }
+    catch (error) {
+        if (error instanceof CommerceError && !misleadsBeforeLaunch(error.code)) {
+            return error.toCommerceErrorInfo();
+        }
+        return gateFailed(`The purchase gate of ${request.store} failed; ${request.logicalId} is not sold now.`, error);
+    }
+    finally {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+        }
+    }
+    if (isRecord(decision) && decision.allowed === true) {
+        return undefined;
+    }
+    if (!isRecord(decision) || decision.allowed !== false) {
+        return gateFailed(`The purchase gate of ${request.store} returned an invalid decision.`);
+    }
+    const storeCode = typeof decision.storeCode === 'string' && decision.storeCode.length > 0
+        ? decision.storeCode
+        : purchasesPausedStoreCode;
+    return new CommerceError('ITEM_UNAVAILABLE', {
+        message: typeof decision.message === 'string' && decision.message.length > 0
+            ? decision.message
+            : `New purchases of ${request.logicalId} are paused.`,
+        storeCode,
+        retryable: decision.retryable === true,
+    }).toCommerceErrorInfo();
+}
+/**
+ * A failed account binding lookup. A `CommerceError` keeps its code (a store
+ * provider names its own lookup failure) unless the code claims a launched or
+ * cancelled sheet; anything else is `ACCOUNT_BINDING_REQUIRED` with
+ * `ACCOUNT_BINDING_LOOKUP_FAILED`, retryable, so every store reports the
+ * same reason.
+ */
+function accountBindingFailure(error, store) {
+    if (error instanceof CommerceError && !misleadsBeforeLaunch(error.code)) {
+        return error.toCommerceErrorInfo();
+    }
+    return new CommerceError('ACCOUNT_BINDING_REQUIRED', {
+        message: `Store ${store} could not resolve the account binding.`,
+        storeCode: accountBindingLookupFailedStoreCode,
+        retryable: true,
+        cause: error,
+    }).toCommerceErrorInfo();
+}
 function assertAvailable(availability, store) {
     switch (availability) {
         case 'available':