@mpgd/game-services 0.30.5 → 0.32.0

package/dist/runtime.js

@@ -1,13 +1,25 @@
-import { createAccountDeletionClient } from './account-deletion.js';
-import { createGameServicesClient, createGameServicesFetchBackendTransport, createGameServicesHttpBackendApi, createGameServicesOrpcBackendApi, createGameServicesOrpcClient, resolveGameServicesRequestHeaders, } from './client.js';
+import { AccountDeletionError, createAccountDeletionClient, } from './account-deletion.js';
+import { CommerceError } from '@mpgd/platform/commerce';
+import { isHostedGameServicesPath } from '@mpgd/platform/routes';
+import { assertCommerceStaleLaunchedAfterMs, createGameServicesClient, createGameServicesFetchBackendTransport, createGameServicesHttpBackendApi, createGameServicesOrpcBackendApi, createGameServicesOrpcClient, resolveGameServicesRequestHeaders, } from './client.js';
+import { gameServicesPlayerChangedCode, GameServicesRuntimeClosedError, gameServicesRuntimeDisposedCode, gameServicesSessionRequiredCode, } from './request-headers.js';
 import { createRecoverableMonetizationClient, } from './monetization-recovery.js';
+/**
+ * How long `dispose()` waits for a purchase whose store sheet is open to
+ * journal its answer, and then for the reconciler to stop: 3 minutes, past
+ * Google Play's own wait for a purchase result.
+ */
+export const gameServicesDisposeWaitMs = 3 * 60 * 1000;
+export { gameServicesPlayerChangedCode, gameServicesRuntimeDisposedCode, GameServicesRuntimeClosedError, gameServicesSessionRequiredCode, } from './request-headers.js';
 export function createGameServicesRuntime(input) {
     assertAuthorityMode(input.authorityMode);
     assertTransport(input.transport);
+    assertCommerceStaleLaunchedAfterMs(input.commerceStaleLaunchedAfterMs);
     if (input.transport === 'orpc' && input.httpTransport !== undefined) {
         throw new Error('Game Services httpTransport cannot be used with oRPC.');
     }
     const target = resolveGameServicesLedgerTarget(input.target ?? input.gateway.target);
+    const gate = createRuntimeGate(input.playerId, input.sessionPlayerId);
     if (target === null) {
         return disabledRuntime('unsupported_target');
     }
@@ -30,10 +42,10 @@ export function createGameServicesRuntime(input) {
             ? createGameServicesOrpcBackendApi(createGameServicesOrpcClient({
                 url: baseUrl,
                 ...(input.headers === undefined ? {} : { headers: input.headers }),
-                ...(input.getHeaders === undefined ? {} : { getHeaders: input.getHeaders }),
+                getHeaders: guardHeaders(input.getHeaders, gate),
             }))
             : createGameServicesHttpBackendApi({
-                transport: withRuntimeHeaders(input.httpTransport ?? createGameServicesFetchBackendTransport({ baseUrl }), input),
+                transport: withRuntimeHeaders(input.httpTransport ?? createGameServicesFetchBackendTransport({ baseUrl }), input, gate),
             });
     }
     else {
@@ -49,8 +61,11 @@ export function createGameServicesRuntime(input) {
         mode = 'local';
         backend = input.localBackend;
     }
+    // Every backend call is refused before it starts once the runtime is closed.
+    backend = guardBackend(backend, gate);
     const clientInput = {
-        gateway: input.gateway,
+        // A rewarded ad queued before the runtime closed is not shown after it.
+        gateway: guardRewardedAds(input.gateway, gate),
         backend,
         playerId: input.playerId,
         target,
@@ -64,6 +79,23 @@ export function createGameServicesRuntime(input) {
         ...(input.now === undefined ? {} : { now: input.now }),
         ...(input.rewardEvidenceRegistry === undefined ? {} : { rewardEvidenceRegistry: input.rewardEvidenceRegistry }),
         ...(input.commerceProducts === undefined ? {} : { commerceProducts: input.commerceProducts }),
+        ...(input.commerceAccountBinding === undefined ? {} : { commerceAccountBinding: input.commerceAccountBinding }),
+        commerceSessionCheck: () => {
+            const refusal = gate.check();
+            return refusal === undefined
+                ? undefined
+                : new CommerceError('ACCOUNT_BINDING_REQUIRED', {
+                    retryable: true,
+                    storeCode: refusal.code,
+                    message: refusal.message,
+                });
+        },
+        // Closed for good, the reconciler starts nothing: a recovery pass that
+        // reaches `start()` after `dispose()` stopped it subscribes nothing.
+        commerceClosed: () => gate.closed,
+        ...(input.commerceStaleLaunchedAfterMs === undefined
+            ? {}
+            : { commerceStaleLaunchedAfterMs: input.commerceStaleLaunchedAfterMs }),
     };
     const monetizationRecovery = input.operationStore === undefined
         ? undefined
@@ -88,34 +120,331 @@ export function createGameServicesRuntime(input) {
                 : { commerceReconciler: monetizationRecovery.commerceReconciler }),
         };
     }
+    const reconciler = routedClient.commerceReconciler;
+    /**
+     * Purchases, rewarded-ad claims, and recovery passes running now:
+     * `dispose()` lets them journal first.
+     */
+    const purchases = new Set();
+    const track = (running) => {
+        purchases.add(running);
+        void running.finally(() => purchases.delete(running)).catch(() => undefined);
+        return running;
+    };
+    const exposedReconciler = reconciler === undefined
+        ? undefined
+        : guardReconciler(reconciler, track);
+    gate.onClose(async () => {
+        // A purchase whose store sheet is open journals the store answer first,
+        // an open rewarded ad its platform result (both stay this player's to
+        // recover), and a recovery pass finishes its start, then the reconciler
+        // stops.
+        await settleWithin(Promise.allSettled([...purchases]), gameServicesDisposeWaitMs);
+        await settleWithin(reconciler?.stop() ?? Promise.resolve(), gameServicesDisposeWaitMs);
+    });
     return {
         mode,
         ...(baseUrl === undefined ? {} : { baseUrl }),
         target,
-        client: routedClient,
-        ...(monetizationRecovery === undefined ? {} : { monetizationRecovery }),
+        client: guardClient(routedClient, gate, track, exposedReconciler),
+        ...(monetizationRecovery === undefined
+            ? {}
+            : { monetizationRecovery: guardRecovery(monetizationRecovery, gate, exposedReconciler, track) }),
         ...(baseUrl === undefined
             ? {}
             : {
-                accountDeletion: createAccountDeletionClient({
+                accountDeletion: guardAccountDeletion(createAccountDeletionClient({
                     // The deletion route is plain HTTP next to the oRPC handler: an
                     // oRPC URL names the handler's `/rpc` prefix, which the route
                     // does not sit under.
                     baseUrl: input.transport === 'orpc' ? baseUrl.replace(/\/rpc\/?$/u, '') : baseUrl,
                     ...(input.headers === undefined ? {} : { headers: input.headers }),
-                    ...(input.getHeaders === undefined ? {} : { getHeaders: input.getHeaders }),
+                    getHeaders: guardHeaders(input.getHeaders, gate),
+                }), gate),
+            }),
+        dispose: () => gate.close(gameServicesRuntimeDisposedCode),
+    };
+}
+function createRuntimeGate(playerId, sessionPlayerId) {
+    let closed;
+    let closing;
+    const teardowns = [];
+    const gate = {
+        check() {
+            if (closed !== undefined) {
+                return closed;
+            }
+            if (sessionPlayerId === undefined) {
+                return undefined;
+            }
+            let current;
+            try {
+                current = sessionPlayerId()?.trim();
+            }
+            catch {
+                current = undefined;
+            }
+            if (current === undefined || current === '') {
+                return new GameServicesRuntimeClosedError(gameServicesSessionRequiredCode);
+            }
+            if (current !== playerId.trim()) {
+                void gate.close(gameServicesPlayerChangedCode);
+                return closed;
+            }
+            return undefined;
+        },
+        get closed() {
+            return closed !== undefined;
+        },
+        assert() {
+            const refusal = gate.check();
+            if (refusal !== undefined) {
+                throw refusal;
+            }
+        },
+        close(code) {
+            closed ??= new GameServicesRuntimeClosedError(code);
+            closing ??= (async () => {
+                for (const teardown of teardowns) {
+                    try {
+                        await teardown();
+                    }
+                    catch {
+                        // Closed regardless: every operation is refused from now on.
+                    }
+                }
+            })();
+            return closing;
+        },
+        onClose(teardown) {
+            teardowns.push(teardown);
+        },
+    };
+    return gate;
+}
+/**
+ * Account deletion refused before anything resolves or is sent: signed out
+ * answers `UNAUTHORIZED` (no session on this device), a closed runtime the
+ * retryable `ACCOUNT_DELETION_UNREACHABLE`. Static headers never stand in
+ * for a session the runtime refuses.
+ */
+function guardAccountDeletion(deletion, gate) {
+    return {
+        ...deletion,
+        async deleteAccount(request) {
+            const refusal = gate.check();
+            if (refusal !== undefined) {
+                throw new AccountDeletionError(refusal.code === gameServicesSessionRequiredCode
+                    ? 'UNAUTHORIZED'
+                    : 'ACCOUNT_DELETION_UNREACHABLE', { requestSent: false, cause: refusal });
+            }
+            return deletion.deleteAccount(request);
+        },
+    };
+}
+function guardHeaders(getHeaders, gate) {
+    return async () => {
+        gate.assert();
+        const headers = (await getHeaders?.()) ?? {};
+        // A session that changed player while its headers were resolved: they
+        // may be the new player's, so they are never sent for this one.
+        gate.assert();
+        return headers;
+    };
+}
+function guardBackend(backend, gate) {
+    const { purchases, adRewards, leaderboard } = backend;
+    const ledgerStatus = purchases.getPurchaseLedgerStatus;
+    const capabilities = purchases.getCommerceCapabilities;
+    return {
+        ...(backend.version === undefined ? {} : { version: backend.version }),
+        purchases: {
+            async verifyPurchase(request) {
+                gate.assert();
+                return purchases.verifyPurchase(request);
+            },
+            ...(ledgerStatus === undefined
+                ? {}
+                : {
+                    async getPurchaseLedgerStatus(request) {
+                        gate.assert();
+                        return ledgerStatus.call(purchases, request);
+                    },
+                }),
+            ...(capabilities === undefined
+                ? {}
+                : {
+                    async getCommerceCapabilities() {
+                        gate.assert();
+                        return capabilities.call(purchases);
+                    },
                 }),
+        },
+        adRewards: {
+            async claimAdReward(request) {
+                gate.assert();
+                return adRewards.claimAdReward(request);
+            },
+        },
+        leaderboard: {
+            async recordScore(request) {
+                gate.assert();
+                return leaderboard.recordScore(request);
+            },
+        },
+    };
+}
+/** Resolves when `work` settles or after `ms`, whichever is first; never rejects. */
+async function settleWithin(work, ms) {
+    let timer;
+    try {
+        await Promise.race([
+            work.then(() => undefined, () => undefined),
+            new Promise((resolve) => {
+                timer = setTimeout(resolve, ms);
             }),
+        ]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * The gateway with a rewarded-ad dispatch that throws the refusal once the
+ * runtime refuses, so no ad opens. It is not an ad outcome: a journaled
+ * operation stays unstarted (not ended), and `claimRewardedAd` answers
+ * `unavailable`.
+ */
+function guardRewardedAds(gateway, gate) {
+    const ads = gateway.ads;
+    return {
+        ...gateway,
+        ads: {
+            ...ads,
+            async showRewarded(request) {
+                gate.assert();
+                return ads.showRewarded(request);
+            },
+        },
     };
 }
-function withRuntimeHeaders(transport, input) {
+/** A reward claim through an open runtime; a dispatch the runtime refused answers `unavailable`. */
+async function guardedReward(gate, track, run) {
+    if (gate.check() !== undefined) {
+        return refusedReward();
+    }
+    try {
+        return await track(run());
+    }
+    catch (error) {
+        if (error instanceof GameServicesRuntimeClosedError) {
+            return refusedReward();
+        }
+        throw error;
+    }
+}
+function refusedPurchase(refusal) {
+    return {
+        status: 'failed',
+        purchase: {
+            status: 'failed',
+            entitlementIds: [],
+            diagnostic: { code: refusal.code, retryable: true },
+        },
+    };
+}
+function refusedReward() {
+    return { status: 'unavailable', reward: { status: 'unavailable', rewardGranted: false } };
+}
+/**
+ * A purchase through an open runtime. A refusal the reconciler gave because
+ * the runtime closed meanwhile answers the runtime's diagnostic, as a
+ * refusal at the entry does.
+ */
+async function guardedPurchase(gate, track, run) {
+    const refusal = gate.check();
+    if (refusal !== undefined) {
+        return refusedPurchase(refusal);
+    }
+    const result = await track(run());
+    const late = result.status === 'failed'
+        && result.purchase.diagnostic?.code === 'ACCOUNT_BINDING_REQUIRED'
+        ? gate.check()
+        : undefined;
+    return late === undefined ? result : refusedPurchase(late);
+}
+/**
+ * The reconciler a runtime exposes. Once the runtime closed for good its
+ * `start()` subscribes nothing (the reconciler's `closed`); while only signed
+ * out it starts as usual and its work waits for the session (its
+ * `sessionCheck`). Its purchases are tracked like the client's, so
+ * `dispose()` waits for an open store sheet's answer.
+ */
+function guardReconciler(reconciler, track) {
+    // The reconciler's getters and methods are closures: the prototype chain serves them.
+    return Object.create(reconciler, {
+        requestPurchase: {
+            value: (request) => track(reconciler.requestPurchase(request)),
+        },
+    });
+}
+/** The client of an open runtime; refusals answer before any store UI or ad opens. */
+function guardClient(client, gate, track, reconciler) {
+    return {
+        ...client,
+        ...(reconciler === undefined ? {} : { commerceReconciler: reconciler }),
+        purchase: (purchase, options) => guardedPurchase(gate, track, () => client.purchase(purchase, options)),
+        claimRewardedAd: (reward, options) => guardedReward(gate, track, () => client.claimRewardedAd(reward, options)),
+        async submitLeaderboardScore(score) {
+            gate.assert();
+            return client.submitLeaderboardScore(score);
+        },
+    };
+}
+function guardRecovery(recovery, gate, reconciler, track) {
+    return {
+        ...recovery,
+        ...(reconciler === undefined ? {} : { commerceReconciler: reconciler }),
+        purchase: (purchase, options) => guardedPurchase(gate, track, () => recovery.purchase(purchase, options)),
+        claimRewardedAd: (reward, options) => guardedReward(gate, track, () => recovery.claimRewardedAd(reward, options)),
+        // A late ad callback is journaled; its claim is refused until a runtime
+        // for the player resends it, so it stays pending, never ended.
+        recoverRewardResult: (idempotencyKey, platform) => recovery.recoverRewardResult(idempotencyKey, platform),
+        async reconcile() {
+            // Startup and resume recovery wait for a runtime the session permits.
+            // `dispose()` waits for a pass under way, so the reconciler it starts
+            // is stopped after it, not before.
+            return gate.check() === undefined ? track(recovery.reconcile()) : [];
+        },
+        async restorePurchases() {
+            gate.assert();
+            let restored;
+            try {
+                restored = await recovery.restorePurchases();
+            }
+            catch (error) {
+                // Closed during the restore: the runtime's refusal says why.
+                gate.assert();
+                throw error;
+            }
+            // Closed during the restore: its passes stopped early for this player.
+            gate.assert();
+            return restored;
+        },
+    };
+}
+function withRuntimeHeaders(transport, input, gate) {
     return {
         async send(request) {
+            gate.assert();
             const headers = await resolveGameServicesRequestHeaders({
                 headers: input.headers,
                 getHeaders: input.getHeaders,
                 requestHeaders: request.headers,
             });
+            // A session that changed player while its headers were resolved: they
+            // may be the new player's, so they are never sent for this one.
+            gate.assert();
             return transport.send({
                 ...request,
                 headers,
@@ -156,12 +485,36 @@ function disabledRuntime(reason, target) {
         mode: 'disabled',
         reason,
         ...(target === undefined ? {} : { target }),
+        // Nothing to close: a disabled runtime holds no client.
+        dispose: async () => undefined,
     };
 }
 function normalizeBaseUrl(baseUrl) {
     const normalized = baseUrl?.trim();
     return normalized === undefined || normalized.length === 0 ? undefined : normalized;
 }
+export { isHostedGameServicesPath };
+/**
+ * Resolve a hosted browser's clean /api ingress before constructing absolute-URL
+ * clients. No ambient DOM access: composition roots supply the actual page origin
+ * and gateway target. Unresolved/invalid inputs remain invalid for the runtime's
+ * fail-closed authority check; this helper never supplies a fallback backend.
+ */
+export function resolveGameServicesBaseUrl(baseUrl, context) {
+    const value = normalizeBaseUrl(baseUrl);
+    if (value === undefined || (context.target !== 'browser' && context.target !== 'microsoft-store')
+        || value !== baseUrl || !isHostedGameServicesPath(value)) {
+        return value;
+    }
+    const origin = context.pageOrigin === undefined
+        ? undefined
+        : parseAbsoluteUrl(context.pageOrigin);
+    if (origin === undefined || origin.origin !== context.pageOrigin
+        || (origin.protocol !== 'https:' && origin.protocol !== 'http:')) {
+        return value;
+    }
+    return new URL(value, origin).href;
+}
 /**
  * Whether a game-services URL may carry a session's credentials in a
  * production build: an absolute https URL with no credentials and a public

package/dist/server.d.ts

@@ -3,6 +3,7 @@ import { type AdPlacements, type ProductCatalog } from '@mpgd/catalog';
 import { type GameServicesBackendApi, type GameServicesBackendTransport, type GameServicesBackendTransportRequest, type GameServicesBackendTransportResponse } from './client.js';
 import { type CommerceEvidenceRegistry } from './commerce-evidence-registry.js';
 import { type PlayerDataErasureInput, type PlayerDataErasureResult } from './account-deletion.js';
+import { purchaseBoundToAnotherAccountCode } from './another-account.js';
 import { type GameServicesHealthResponse } from './contract.js';
 import { type GameServicesEvidenceVerifier, type GameServicesPurchaseGrantFinalizer } from './evidence-verification.js';
 import { type ClaimAdRewardRequest, type ClaimAdRewardResponse, type EntitlementLedgerGrant, type EntitlementLedgerNote, type EntitlementLedgerResult, type EntitlementLedgerRevocation, type EntitlementRevocationTransaction, type GameServicesAdRewardTarget, type GameServicesStoreTarget, type LeaderboardScoreTransaction, type ProductGrantTransaction, type PurchaseLedgerStatusRequest, type RecordLeaderboardScoreRequest, type RecordLeaderboardScoreResponse, type VerifyPurchaseRequest, type VerifyPurchaseResponse } from './types.js';
@@ -58,11 +59,15 @@ export interface GameServicesBackendApiHandler {
   handle(request: GameServicesBackendTransportRequest): Promise<GameServicesBackendTransportResponse>;
 }
 /** Stable error codes emitted by the backend API handler and the HTTP fetch handler. */
-export type GameServicesBackendErrorCode = 'INVALID_REQUEST' | 'INVALID_JSON' | 'PAYLOAD_TOO_LARGE' | 'METHOD_NOT_ALLOWED' | 'UNKNOWN_ENDPOINT' | 'INTERNAL_ERROR';
+export type GameServicesBackendErrorCode = 'INVALID_REQUEST' | 'INVALID_JSON' | 'PAYLOAD_TOO_LARGE' | 'METHOD_NOT_ALLOWED' | 'UNKNOWN_ENDPOINT' | 'INTERNAL_ERROR'
+/** 409: the store binds the purchase to another account (RFC "Another account's purchase"). */
+| typeof purchaseBoundToAnotherAccountCode;
 export interface GameServicesBackendErrorResponse {
   readonly error: GameServicesBackendErrorCode;
   /** Present only for `INVALID_REQUEST`; never carries internal failure details. */
   readonly message?: string;
+  /** Present only for `PURCHASE_BOUND_TO_ANOTHER_ACCOUNT`: the store's binding mismatch. */
+  readonly reason?: string;
 }
 export interface GameServicesStore {
   recordEntitlementGrant(input: EntitlementLedgerGrant): Promise<EntitlementLedgerResult>;
@@ -152,6 +157,15 @@ export interface CreateGameServicesRouterOptions {
 }
 export interface CreateGameServicesRpcFetchHandlerOptions extends CreateGameServicesFetchHandlerOptions {
   readonly prefix?: string;
+  /**
+  * Writes the pre-beta.34 `inferable: false` flag into oRPC error bodies so game clients
+  * from `@mpgd/game-services` 0.30.5 or older (oRPC 2.0.0-beta.14) still decode error
+  * codes. A plain oRPC 2.0.0-beta.34+ client rejects that flag: such clients must wrap their
+  * fetch with `withLegacyOrpcErrorCompat`, as `createGameServicesOrpcClient` from 0.31.0 or
+  * later does. Set this to false once every supported game client comes from 0.31.0 or
+  * later. Defaults to true.
+  */
+  readonly legacyOrpcErrorFlag?: boolean;
 }
 export interface GameServicesOrpcContext {
   readonly request?: Request;
@@ -217,19 +231,29 @@ export declare function createGameServicesBackend(input: CreateGameServicesBacke
 export declare function createGameServicesBackendApiHandler(input: CreateGameServicesBackendInput): GameServicesBackendApiHandler;
 export declare function createInProcessGameServicesBackendTransport(handler: GameServicesBackendApiHandler): GameServicesBackendTransport;
 export declare function createGameServicesRouter(backend: GameServicesBackendApi, options?: CreateGameServicesRouterOptions): {
-  health: import("@orpc/server").ImplementedProcedure<GameServicesOrpcContext & object, object, import("@orpc/contract").Schema<void, void>, import("@orpc/contract").Schema<GameServicesHealthResponse, GameServicesHealthResponse>, object>;
+  health: import("@orpc/server").ImplementedProcedure<GameServicesOrpcContext & object, object, import("@orpc/contract").Schema<void, void>, import("@orpc/contract").Schema<GameServicesHealthResponse, GameServicesHealthResponse>, Record<never, never>>;
   commerce: {
-    verifyPurchase: import("@orpc/server").ImplementedProcedure<GameServicesOrpcContext & object, object, import("@orpc/contract").Schema<VerifyPurchaseRequest, VerifyPurchaseRequest>, import("@orpc/contract").Schema<VerifyPurchaseResponse, VerifyPurchaseResponse>, object>;
-    getPurchaseLedgerStatus: import("@orpc/server").ImplementedProcedure<GameServicesOrpcContext & object, object, import("@orpc/contract").Schema<PurchaseLedgerStatusRequest, PurchaseLedgerStatusRequest>, import("@orpc/contract").Schema<import("./operation-results.js").PurchaseLedgerStatusResponse, import("./operation-results.js").PurchaseLedgerStatusResponse>, object>;
-    getCapabilities: import("@orpc/server").ImplementedProcedure<GameServicesOrpcContext & object, object, import("@orpc/contract").Schema<void, void>, import("@orpc/contract").Schema<import("@mpgd/platform/commerce").CommerceServiceCapabilities, import("@mpgd/platform/commerce").CommerceServiceCapabilities>, object>;
+    verifyPurchase: import("@orpc/server").ImplementedProcedure<GameServicesOrpcContext & object, object, import("@orpc/contract").Schema<VerifyPurchaseRequest, VerifyPurchaseRequest>, import("@orpc/contract").Schema<VerifyPurchaseResponse, VerifyPurchaseResponse>, Record<never, never>>;
+    getPurchaseLedgerStatus: import("@orpc/server").ImplementedProcedure<GameServicesOrpcContext & object, object, import("@orpc/contract").Schema<PurchaseLedgerStatusRequest, PurchaseLedgerStatusRequest>, import("@orpc/contract").Schema<import("./operation-results.js").PurchaseLedgerStatusResponse, import("./operation-results.js").PurchaseLedgerStatusResponse>, Record<never, never>>;
+    getCapabilities: import("@orpc/server").ImplementedProcedure<GameServicesOrpcContext & object, object, import("@orpc/contract").Schema<void, void>, import("@orpc/contract").Schema<import("@mpgd/platform/commerce").CommerceServiceCapabilities, import("@mpgd/platform/commerce").CommerceServiceCapabilities>, Record<never, never>>;
   };
   ads: {
-    claimReward: import("@orpc/server").ImplementedProcedure<GameServicesOrpcContext & object, object, import("@orpc/contract").Schema<ClaimAdRewardRequest, ClaimAdRewardRequest>, import("@orpc/contract").Schema<ClaimAdRewardResponse, ClaimAdRewardResponse>, object>;
+    claimReward: import("@orpc/server").ImplementedProcedure<GameServicesOrpcContext & object, object, import("@orpc/contract").Schema<ClaimAdRewardRequest, ClaimAdRewardRequest>, import("@orpc/contract").Schema<ClaimAdRewardResponse, ClaimAdRewardResponse>, Record<never, never>>;
   };
   leaderboard: {
-    recordScore: import("@orpc/server").ImplementedProcedure<GameServicesOrpcContext & object, object, import("@orpc/contract").Schema<RecordLeaderboardScoreRequest, RecordLeaderboardScoreRequest>, import("@orpc/contract").Schema<RecordLeaderboardScoreResponse, RecordLeaderboardScoreResponse>, object>;
+    recordScore: import("@orpc/server").ImplementedProcedure<GameServicesOrpcContext & object, object, import("@orpc/contract").Schema<RecordLeaderboardScoreRequest, RecordLeaderboardScoreRequest>, import("@orpc/contract").Schema<RecordLeaderboardScoreResponse, RecordLeaderboardScoreResponse>, Record<never, never>>;
   };
 };
+/**
+* The RPC handler's error status map: oRPC's common codes and
+* `PURCHASE_BOUND_TO_ANOTHER_ACCOUNT` at 409. oRPC 2.0.0-beta.46 derives the
+* HTTP status of an error from its code through this map (an `ORPCError`
+* carries no status of its own), so a host that mounts
+* `createGameServicesRouter` in its own `RPCHandler` passes it as
+* `errorStatusMap` to answer 409 too; without it the code still reaches the
+* client, with status 500.
+*/
+export declare const gameServicesRpcErrorStatusMap: Readonly<Record<string, number>>;
 export declare function createGameServicesRpcFetchHandler(router: ReturnType<typeof createGameServicesRouter>, options?: CreateGameServicesRpcFetchHandlerOptions): (request: Request) => Promise<Response>;
 export declare function createGameServicesHttpFetchHandler(handler: GameServicesBackendApiHandler, options?: CreateGameServicesFetchHandlerOptions): (request: Request) => Promise<Response>;
 export * from './notification-delivery.js';