@mpgd/game-services 0.13.1 → 0.15.0

package/dist/index.js

@@ -1,17 +1,18 @@
 export * from './admob-ssv.js';
-export * from './app-store-verifier';
-export * from './apps-in-toss-evidence-verification';
-export * from './apps-in-toss-partner-api';
-export * from './client';
-export * from './contract';
-export * from './evidence-verification';
-export * from './google-play-purchase';
-export * from './microsoft-store-purchase';
-export * from './notification-delivery';
-export * from './platform-order';
-export * from './progress-link';
+export * from './app-store-verifier.js';
+export * from './apps-in-toss-evidence-verification.js';
+export * from './apps-in-toss-partner-api.js';
+export * from './client.js';
+export * from './contract.js';
+export * from './evidence-verification.js';
+export * from './google-play-purchase.js';
+export * from './microsoft-store-identity.js';
+export * from './microsoft-store-purchase.js';
+export * from './notification-delivery.js';
+export * from './platform-order.js';
+export * from './progress-link.js';
 export * from './runtime.js';
-export * from './server';
-export * from './types';
-export * from './verified-leaderboard';
-export * from './verified-leaderboard-transport';
+export * from './server.js';
+export * from './types.js';
+export * from './verified-leaderboard.js';
+export * from './verified-leaderboard-transport.js';

package/dist/microsoft-store-identity.d.ts

@@ -0,0 +1,39 @@
+import type { MicrosoftStoreCollectionsCredentials } from './microsoft-store-purchase.js';
+export declare const microsoftStoreIdentityCredentialsSchema: 'mpgd.microsoft-store.identity-credentials.v1';
+export declare const microsoftStoreIdentityCredentialsRequestUrl: 'https://microsoft-store-authority.internal/v1/credentials';
+export interface MicrosoftStoreIdentityCredentialsRequest {
+  readonly schema: typeof microsoftStoreIdentityCredentialsSchema;
+  readonly gameId: string;
+  readonly playerId: string;
+}
+export interface MicrosoftStoreIdentityCredentialsResponse extends MicrosoftStoreCollectionsCredentials {
+  readonly schema: typeof microsoftStoreIdentityCredentialsSchema;
+  readonly gameId: string;
+  readonly playerId: string;
+}
+export interface MicrosoftStoreIdentityAuthorityFetcher {
+  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+}
+export declare class MicrosoftStoreIdentityAuthorityError extends Error {
+  readonly code: 'MICROSOFT_STORE_ACCOUNT_LINK_REQUIRED' | 'MICROSOFT_STORE_IDENTITY_RESPONSE_INVALID' | 'MICROSOFT_STORE_IDENTITY_UNAVAILABLE';
+  readonly name = "MicrosoftStoreIdentityAuthorityError";
+  constructor(code: 'MICROSOFT_STORE_ACCOUNT_LINK_REQUIRED' | 'MICROSOFT_STORE_IDENTITY_RESPONSE_INVALID' | 'MICROSOFT_STORE_IDENTITY_UNAVAILABLE', options?: ErrorOptions);
+}
+export declare function parseMicrosoftStoreIdentityCredentialsRequest(value: unknown): MicrosoftStoreIdentityCredentialsRequest;
+export declare function createMicrosoftStoreIdentityCredentialsResponse(input: {
+  readonly request: MicrosoftStoreIdentityCredentialsRequest;
+  readonly credentials: MicrosoftStoreCollectionsCredentials;
+}): MicrosoftStoreIdentityCredentialsResponse;
+export declare function parseMicrosoftStoreIdentityCredentialsResponse(value: unknown, expectedRequest?: MicrosoftStoreIdentityCredentialsRequest): MicrosoftStoreIdentityCredentialsResponse;
+/**
+* Resolves short-lived Store credentials over a private service binding. The authority request is
+* scoped by both game and player so a shared provider Worker cannot accidentally reuse one game's
+* account link for another game. The returned credentials must never be exposed to a browser.
+*/
+export declare function resolveMicrosoftStoreIdentityCredentials(input: {
+  readonly authority: MicrosoftStoreIdentityAuthorityFetcher;
+  readonly gameId: string;
+  readonly playerId: string;
+  readonly signal?: AbortSignal;
+  readonly timeoutMs?: number;
+}): Promise<MicrosoftStoreIdentityCredentialsResponse>;

package/dist/microsoft-store-identity.js

@@ -0,0 +1,304 @@
+export const microsoftStoreIdentityCredentialsSchema = 'mpgd.microsoft-store.identity-credentials.v1';
+export const microsoftStoreIdentityCredentialsRequestUrl = 'https://microsoft-store-authority.internal/v1/credentials';
+const defaultTimeoutMs = 8000;
+const maximumResponseBytes = 16 * 1024;
+const gameIdPattern = /^[a-z0-9][a-z0-9-]{0,63}$/u;
+export class MicrosoftStoreIdentityAuthorityError extends Error {
+    code;
+    name = 'MicrosoftStoreIdentityAuthorityError';
+    constructor(code, options) {
+        super(code, options);
+        this.code = code;
+    }
+}
+export function parseMicrosoftStoreIdentityCredentialsRequest(value) {
+    const record = requireExactRecord(value, ['schema', 'gameId', 'playerId']);
+    if (record.schema !== microsoftStoreIdentityCredentialsSchema) {
+        throw new TypeError('Microsoft Store identity request schema is invalid.');
+    }
+    return Object.freeze({
+        schema: microsoftStoreIdentityCredentialsSchema,
+        gameId: requireGameId(record.gameId),
+        playerId: requireText(record.playerId, 'playerId', 256),
+    });
+}
+export function createMicrosoftStoreIdentityCredentialsResponse(input) {
+    const request = parseMicrosoftStoreIdentityCredentialsRequest(input.request);
+    return parseMicrosoftStoreIdentityCredentialsResponse({
+        schema: microsoftStoreIdentityCredentialsSchema,
+        gameId: request.gameId,
+        playerId: request.playerId,
+        accessToken: input.credentials.accessToken,
+        userStoreId: input.credentials.userStoreId,
+        accountBindingId: input.credentials.accountBindingId,
+        ...(input.credentials.sandbox === undefined
+            ? {}
+            : { sandbox: input.credentials.sandbox }),
+    }, request);
+}
+export function parseMicrosoftStoreIdentityCredentialsResponse(value, expectedRequest) {
+    const record = requireExactRecord(value, ['schema', 'gameId', 'playerId', 'accessToken', 'userStoreId', 'accountBindingId'], ['sandbox']);
+    if (record.schema !== microsoftStoreIdentityCredentialsSchema) {
+        throw new TypeError('Microsoft Store identity response schema is invalid.');
+    }
+    const response = Object.freeze({
+        schema: microsoftStoreIdentityCredentialsSchema,
+        gameId: requireGameId(record.gameId),
+        playerId: requireText(record.playerId, 'response playerId', 256),
+        accessToken: requireToken(record.accessToken, 'Microsoft Store access token', 4096),
+        userStoreId: requireToken(record.userStoreId, 'Microsoft Store User Store ID', 4096),
+        accountBindingId: requireText(record.accountBindingId, 'Microsoft Store account binding ID', 512),
+        ...(record.sandbox === undefined
+            ? {}
+            : { sandbox: requireText(record.sandbox, 'Microsoft Store sandbox', 256) }),
+    });
+    if (expectedRequest !== undefined
+        && (response.gameId !== expectedRequest.gameId
+            || response.playerId !== expectedRequest.playerId)) {
+        throw new TypeError('Microsoft Store identity response scope does not match the request.');
+    }
+    return response;
+}
+/**
+ * Resolves short-lived Store credentials over a private service binding. The authority request is
+ * scoped by both game and player so a shared provider Worker cannot accidentally reuse one game's
+ * account link for another game. The returned credentials must never be exposed to a browser.
+ */
+export async function resolveMicrosoftStoreIdentityCredentials(input) {
+    const request = parseMicrosoftStoreIdentityCredentialsRequest({
+        schema: microsoftStoreIdentityCredentialsSchema,
+        gameId: input.gameId,
+        playerId: input.playerId,
+    });
+    const timeoutMs = input.timeoutMs ?? defaultTimeoutMs;
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 25000) {
+        throw new TypeError('Microsoft Store identity timeout is invalid.');
+    }
+    const abort = createAbortScope(input.signal, timeoutMs);
+    try {
+        let response;
+        try {
+            response = await raceWithAbort(input.authority.fetch(microsoftStoreIdentityCredentialsRequestUrl, {
+                method: 'POST',
+                headers: {
+                    Accept: 'application/json',
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(request),
+                signal: abort.signal,
+            }), abort.signal);
+        }
+        catch (cause) {
+            if (isAbortCause(abort.signal, cause)) {
+                throw abort.signal.reason;
+            }
+            throw unavailable(cause);
+        }
+        if (!response.ok) {
+            await discardResponseBody(response, abort.signal);
+            const accountLinkRequired = response.status === 404 || response.status === 409;
+            const code = accountLinkRequired
+                ? 'MICROSOFT_STORE_ACCOUNT_LINK_REQUIRED'
+                : 'MICROSOFT_STORE_IDENTITY_UNAVAILABLE';
+            const options = accountLinkRequired
+                ? undefined
+                : { cause: authorityHttpStatusError(response.status) };
+            throw new MicrosoftStoreIdentityAuthorityError(code, options);
+        }
+        try {
+            return parseMicrosoftStoreIdentityCredentialsResponse(await readBoundedJson(response, maximumResponseBytes, abort.signal), request);
+        }
+        catch (cause) {
+            if (cause instanceof MicrosoftStoreIdentityAuthorityError) {
+                throw cause;
+            }
+            if (isAbortCause(abort.signal, cause)) {
+                throw abort.signal.reason;
+            }
+            throw invalidResponse(cause);
+        }
+    }
+    finally {
+        abort.cleanup();
+    }
+}
+function requireExactRecord(value, requiredKeys, optionalKeys = []) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new TypeError('Microsoft Store identity payload must be an object.');
+    }
+    const record = value;
+    const allowed = new Set([...requiredKeys, ...optionalKeys]);
+    if (requiredKeys.some((key) => !Object.hasOwn(record, key))
+        || Object.keys(record).some((key) => !allowed.has(key))) {
+        throw new TypeError('Microsoft Store identity payload shape is invalid.');
+    }
+    return record;
+}
+function requireGameId(value) {
+    if (typeof value !== 'string' || !gameIdPattern.test(value)) {
+        throw new TypeError('Microsoft Store identity gameId is invalid.');
+    }
+    return value;
+}
+function requireText(value, label, maximumLength) {
+    if (typeof value !== 'string'
+        || value.length === 0
+        || value.length > maximumLength
+        || value.trim() !== value
+        || /[\p{Cc}\p{Cf}]/u.test(value)
+        || !isWellFormedUnicode(value)) {
+        throw new TypeError(`${label} is invalid.`);
+    }
+    return value;
+}
+function requireToken(value, label, maximumLength) {
+    const token = requireText(value, label, maximumLength);
+    if (/\s/u.test(token)) {
+        throw new TypeError(`${label} is invalid.`);
+    }
+    return token;
+}
+function isWellFormedUnicode(input) {
+    for (let index = 0; index < input.length; index += 1) {
+        const codeUnit = input.charCodeAt(index);
+        if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
+            const nextCodeUnit = input.charCodeAt(index + 1);
+            if (index + 1 >= input.length
+                || nextCodeUnit < 0xdc00
+                || nextCodeUnit > 0xdfff) {
+                return false;
+            }
+            index += 1;
+        }
+        else if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) {
+            return false;
+        }
+    }
+    return true;
+}
+function createAbortScope(upstream, timeoutMs) {
+    const controller = new AbortController();
+    const onAbort = () => controller.abort(upstream?.reason);
+    if (upstream?.aborted === true) {
+        onAbort();
+    }
+    else {
+        upstream?.addEventListener('abort', onAbort, { once: true });
+    }
+    const timeout = setTimeout(() => controller.abort(new Error('Microsoft Store identity request timed out.')), timeoutMs);
+    return Object.freeze({
+        signal: controller.signal,
+        cleanup() {
+            clearTimeout(timeout);
+            upstream?.removeEventListener('abort', onAbort);
+        },
+    });
+}
+async function readBoundedJson(response, maximumBytes, signal) {
+    const contentLengthHeader = response.headers.get('content-length');
+    if (contentLengthHeader !== null) {
+        if (!/^\d+$/u.test(contentLengthHeader)) {
+            await discardResponseBody(response, signal);
+            throw new TypeError('Microsoft Store identity response content length is invalid.');
+        }
+        const contentLength = Number(contentLengthHeader);
+        if (!Number.isSafeInteger(contentLength)) {
+            await discardResponseBody(response, signal);
+            throw new TypeError('Microsoft Store identity response content length is invalid.');
+        }
+        if (contentLength > maximumBytes) {
+            await discardResponseBody(response, signal);
+            throw new TypeError('Microsoft Store identity response is too large.');
+        }
+    }
+    if (response.body === null) {
+        if (signal.aborted) {
+            throw signal.reason;
+        }
+        throw new TypeError('Microsoft Store identity response body is missing.');
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            if (signal.aborted) {
+                throw signal.reason;
+            }
+            const result = await raceWithAbort(reader.read(), signal);
+            if (result.done) {
+                break;
+            }
+            if (!(result.value instanceof Uint8Array)) {
+                throw new TypeError('Microsoft Store identity response chunk is invalid.');
+            }
+            total += result.value.byteLength;
+            if (total > maximumBytes) {
+                throw new TypeError('Microsoft Store identity response is too large.');
+            }
+            chunks.push(result.value);
+        }
+    }
+    finally {
+        await raceWithAbort(reader.cancel(), signal).catch(() => undefined);
+        try {
+            reader.releaseLock();
+        }
+        catch (cause) {
+            if (!signal.aborted) {
+                throw cause;
+            }
+        }
+        if (signal.aborted) {
+            throw signal.reason;
+        }
+    }
+    const bytes = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(bytes));
+}
+function unavailable(cause) {
+    return new MicrosoftStoreIdentityAuthorityError('MICROSOFT_STORE_IDENTITY_UNAVAILABLE', cause === undefined ? undefined : { cause });
+}
+function invalidResponse(cause) {
+    return new MicrosoftStoreIdentityAuthorityError('MICROSOFT_STORE_IDENTITY_RESPONSE_INVALID', cause === undefined ? undefined : { cause });
+}
+function authorityHttpStatusError(status) {
+    return new Error(`Microsoft Store identity authority returned HTTP ${String(status)}.`);
+}
+async function discardResponseBody(response, signal) {
+    if (response.body !== null) {
+        await raceWithAbort(response.body.cancel(), signal).catch(() => undefined);
+    }
+    if (signal.aborted) {
+        throw signal.reason;
+    }
+}
+function raceWithAbort(operation, signal) {
+    if (signal.aborted) {
+        return Promise.race([operation, Promise.reject(signal.reason)]);
+    }
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            signal.removeEventListener('abort', onAbort);
+            reject(signal.reason);
+        };
+        signal.addEventListener('abort', onAbort, { once: true });
+        operation.then((value) => {
+            signal.removeEventListener('abort', onAbort);
+            resolve(value);
+        }, (cause) => {
+            signal.removeEventListener('abort', onAbort);
+            reject(cause);
+        });
+    });
+}
+function isAbortCause(signal, cause) {
+    return signal.aborted
+        && (cause === signal.reason
+            || (cause instanceof Error && cause.name === 'AbortError'));
+}

package/dist/microsoft-store-purchase.d.ts

@@ -1,4 +1,4 @@
-import type { GameServicesEvidenceVerifier, GameServicesPurchaseGrantFinalizer, VerifyPurchaseEvidenceInput } from './evidence-verification';
+import type { GameServicesEvidenceVerifier, GameServicesPurchaseGrantFinalizer, VerifyPurchaseEvidenceInput } from './evidence-verification.js';
 export declare const microsoftStoreDigitalGoodsEvidenceSchema: 'mpgd.microsoft-store.digital-goods.v1';
 export declare const microsoftStoreCollectionsQueryUrl: 'https://collections.mp.microsoft.com/v9.0/collections/publisherQuery';
 export declare const microsoftStoreCollectionsConsumeUrl: 'https://collections.mp.microsoft.com/v8.0/collections/consume';

package/dist/notification-delivery.js

@@ -1,4 +1,4 @@
-import { assertOwnEnumerablePropertyLimit } from './validation';
+import { assertOwnEnumerablePropertyLimit } from './validation.js';
 const platformTargets = new Set([
     'browser',
     'android',
@@ -9,6 +9,8 @@ const platformTargets = new Set([
     'telegram',
     'tauri',
     'microsoft-store',
+    'wechat',
+    'tiktok',
 ]);
 const notificationTopics = new Set([
     'daily-ready',

package/dist/operation-progress.d.ts

@@ -0,0 +1,47 @@
+import type { PurchaseResult, RewardedAdResult } from '@mpgd/platform';
+import type { GameServicesPurchaseResult, GameServicesRewardedAdResult } from './operations.js';
+export type GameServicesOperationKind = 'purchase' | 'rewarded-ad';
+export type GameServicesOperationLocation = 'local' | 'platform' | 'server';
+type PlatformStatus<K extends GameServicesOperationKind> = K extends 'purchase' ? PurchaseResult['status'] : RewardedAdResult['status'];
+type OperationResult<K extends GameServicesOperationKind> = K extends 'purchase' ? GameServicesPurchaseResult : GameServicesRewardedAdResult;
+type ProgressStage<K extends GameServicesOperationKind> = {
+  readonly phase: 'platform-requested';
+} | {
+  readonly phase: 'platform-result';
+  readonly status: PlatformStatus<K>;
+} | {
+  readonly phase: 'server-requested';
+} | {
+  readonly phase: 'server-result';
+  readonly accepted: boolean;
+} | {
+  readonly phase: 'completed';
+  readonly status: OperationResult<K>['status'];
+} | {
+  readonly phase: 'exception';
+  readonly at: GameServicesOperationLocation;
+};
+type OperationProgress<K extends GameServicesOperationKind> = ProgressStage<K> & {
+  readonly kind: K;
+  /** Invocation-local event order, starting at one. */
+  readonly sequence: number;
+  /** Optional UI/diagnostic correlation, never an idempotency key or grant proof. */
+  readonly correlationId?: string;
+};
+export type GameServicesPurchaseProgress = OperationProgress<'purchase'>;
+export type GameServicesRewardedAdProgress = OperationProgress<'rewarded-ad'>;
+export type GameServicesOperationProgress = GameServicesPurchaseProgress | GameServicesRewardedAdProgress;
+export interface GameServicesOperationOptions<TProgress = GameServicesOperationProgress> {
+  readonly onProgress?: (progress: TProgress) => void | Promise<void>;
+  readonly onObserverError?: (error: unknown) => void | Promise<void>;
+  readonly correlationId?: string;
+}
+interface OperationReporter<K extends GameServicesOperationKind> {
+  platformRequested(): void;
+  platformResult(status: PlatformStatus<K>): void;
+  serverRequested(): void;
+  serverResult(accepted: boolean): void;
+}
+/** Internal observation wrapper; it does not retry, cancel, verify, or grant anything. */
+export declare function observeGameServicesOperation<K extends GameServicesOperationKind>(kind: K, options: GameServicesOperationOptions<OperationProgress<K>> | undefined, operation: (reporter: OperationReporter<K>) => Promise<OperationResult<K>>): Promise<OperationResult<K>>;
+export {};

package/dist/operation-progress.js

@@ -0,0 +1,87 @@
+/** Internal observation wrapper; it does not retry, cancel, verify, or grant anything. */
+export async function observeGameServicesOperation(kind, options, operation) {
+    let onProgress;
+    let onObserverError;
+    let correlationId;
+    let sequence = 0;
+    let location = 'local';
+    function report(error) {
+        try {
+            if (typeof onObserverError === 'function') {
+                const result = onObserverError(error);
+                if (result !== undefined) {
+                    void Promise.resolve(result).catch(() => { });
+                }
+            }
+        }
+        catch {
+            // Diagnostic callbacks have no authority to change business results.
+        }
+    }
+    // Capture observation options once. Even accessor failures stay outside the business flow.
+    try {
+        onObserverError = options?.onObserverError;
+    }
+    catch {
+        // There is no safe error observer to invoke if retrieving it failed.
+    }
+    try {
+        onProgress = options?.onProgress;
+        const suppliedId = options?.correlationId;
+        if (typeof suppliedId === 'string') {
+            correlationId = suppliedId;
+        }
+    }
+    catch (error) {
+        report(error);
+    }
+    function emit(stage) {
+        sequence += 1;
+        if (typeof onProgress !== 'function') {
+            return;
+        }
+        const observer = onProgress;
+        const progress = Object.freeze({
+            ...stage,
+            kind,
+            sequence,
+            ...(correlationId === undefined ? {} : { correlationId }),
+        });
+        try {
+            const result = observer(progress);
+            if (result !== undefined) {
+                void Promise.resolve(result).catch(report);
+            }
+        }
+        catch (error) {
+            report(error);
+        }
+    }
+    const reporter = {
+        platformRequested() {
+            location = 'platform';
+            emit({ phase: 'platform-requested' });
+        },
+        platformResult(status) {
+            location = 'local';
+            emit({ phase: 'platform-result', status });
+        },
+        serverRequested() {
+            location = 'server';
+            emit({ phase: 'server-requested' });
+        },
+        serverResult(accepted) {
+            location = 'local';
+            emit({ phase: 'server-result', accepted });
+        },
+    };
+    try {
+        const result = await operation(reporter);
+        emit({ phase: 'completed', status: result.status });
+        return result;
+    }
+    catch (error) {
+        emit({ phase: 'exception', at: location });
+        throw error;
+    }
+}

package/dist/operations.d.ts

@@ -0,0 +1,30 @@
+import type { LogicalAdPlacementId, LogicalProductId, PurchaseResult, RewardedAdResult } from '@mpgd/platform';
+import type { GameServicesOperationOptions, GameServicesPurchaseProgress, GameServicesRewardedAdProgress } from './operation-progress.js';
+import type { ClaimAdRewardResponse, VerifyPurchaseResponse } from './types.js';
+export type { GameServicesOperationKind, GameServicesOperationLocation, GameServicesOperationOptions, GameServicesOperationProgress, GameServicesPurchaseProgress, GameServicesRewardedAdProgress, } from './operation-progress.js';
+/** DOM-free public operation port, implemented by GameServicesClient. */
+export interface GameServicesOperationClient {
+  purchase(input: GameServicesPurchaseInput, options?: GameServicesOperationOptions<GameServicesPurchaseProgress>): Promise<GameServicesPurchaseResult>;
+  claimRewardedAd(input: GameServicesRewardedAdInput, options?: GameServicesOperationOptions<GameServicesRewardedAdProgress>): Promise<GameServicesRewardedAdResult>;
+}
+export interface GameServicesPurchaseInput {
+  readonly productId: LogicalProductId;
+  readonly source: 'shop' | 'stage_fail' | 'result' | 'event';
+  readonly idempotencyKey: string;
+}
+export interface GameServicesPurchaseResult {
+  readonly status: 'granted' | 'cancelled' | 'pending' | 'failed' | 'rejected';
+  readonly purchase: PurchaseResult;
+  readonly verification?: VerifyPurchaseResponse;
+  readonly ledgerEntryId?: string;
+}
+export interface GameServicesRewardedAdInput {
+  readonly placementId: LogicalAdPlacementId;
+  readonly idempotencyKey: string;
+}
+export interface GameServicesRewardedAdResult {
+  readonly status: 'granted' | 'skipped' | 'unavailable' | 'failed' | 'rejected';
+  readonly reward: RewardedAdResult;
+  readonly claim?: ClaimAdRewardResponse;
+  readonly ledgerEntryId?: string;
+}

package/dist/operations.js

@@ -0,0 +1 @@
+export {};

package/dist/progress-link.js

@@ -1,4 +1,4 @@
-import { assertOwnEnumerablePropertyLimit } from './validation';
+import { assertOwnEnumerablePropertyLimit } from './validation.js';
 export const gameProgressLimits = {
     maxIdentifierLength: 256,
     maxCompletedIds: 512,

package/dist/server.d.ts

@@ -1,9 +1,9 @@
 import { type AnalyticsSink } from '@mpgd/analytics';
 import { type AdPlacements, type ProductCatalog } from '@mpgd/catalog';
-import { type GameServicesBackendApi, type GameServicesBackendTransport, type GameServicesBackendTransportRequest, type GameServicesBackendTransportResponse } from './client';
-import { type GameServicesHealthResponse } from './contract';
-import { type GameServicesEvidenceVerifier, type GameServicesPurchaseGrantFinalizer } from './evidence-verification';
-import { type ClaimAdRewardRequest, type ClaimAdRewardResponse, type EntitlementLedgerGrant, type EntitlementLedgerResult, type GameServicesAdRewardTarget, type GameServicesStoreTarget, type LeaderboardScoreTransaction, type ProductGrantTransaction, type RecordLeaderboardScoreRequest, type RecordLeaderboardScoreResponse, type VerifyPurchaseRequest, type VerifyPurchaseResponse } from './types';
+import { type GameServicesBackendApi, type GameServicesBackendTransport, type GameServicesBackendTransportRequest, type GameServicesBackendTransportResponse } from './client.js';
+import { type GameServicesHealthResponse } from './contract.js';
+import { type GameServicesEvidenceVerifier, type GameServicesPurchaseGrantFinalizer } from './evidence-verification.js';
+import { type ClaimAdRewardRequest, type ClaimAdRewardResponse, type EntitlementLedgerGrant, type EntitlementLedgerResult, type GameServicesAdRewardTarget, type GameServicesStoreTarget, type LeaderboardScoreTransaction, type ProductGrantTransaction, type RecordLeaderboardScoreRequest, type RecordLeaderboardScoreResponse, type VerifyPurchaseRequest, type VerifyPurchaseResponse } from './types.js';
 type CorsHeaders = Record<string, string>;
 export interface CreateGameServicesBackendInput {
   readonly catalog: ProductCatalog;
@@ -113,5 +113,5 @@ export declare function createGameServicesRouter(backend: GameServicesBackendApi
 };
 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';
-export * from './progress-link';
+export * from './notification-delivery.js';
+export * from './progress-link.js';

package/dist/server.js

@@ -2,10 +2,10 @@ import { implement } from '@orpc/server';
 import { RPCHandler } from '@orpc/server/fetch';
 import { createAnalyticsReporter } from '@mpgd/analytics';
 import { resolveAdPlacementPlatformId, resolveProductPlatformId, } from '@mpgd/catalog';
-import { gameServicesBackendEndpoints, } from './client';
-import { gameServicesContract } from './contract';
-import { createRejectingGameServicesEvidenceVerifier, } from './evidence-verification';
-import { assertClaimAdRewardRequest, assertClaimAdRewardResponse, assertEntitlementLedgerGrant, assertEntitlementLedgerResult, assertGameServicesDeploymentTarget, assertLeaderboardScoreTransaction, assertProductGrantTransaction, assertPurchaseGrantFinalization, assertRecordLeaderboardScoreRequest, assertRecordLeaderboardScoreResponse, assertVerifyPurchaseRequest, assertVerifyPurchaseResponse, } from './types';
+import { gameServicesBackendEndpoints, } from './client.js';
+import { gameServicesContract } from './contract.js';
+import { createRejectingGameServicesEvidenceVerifier, } from './evidence-verification.js';
+import { assertClaimAdRewardRequest, assertClaimAdRewardResponse, assertEntitlementLedgerGrant, assertEntitlementLedgerResult, assertGameServicesDeploymentTarget, assertLeaderboardScoreTransaction, assertProductGrantTransaction, assertPurchaseGrantFinalization, assertRecordLeaderboardScoreRequest, assertRecordLeaderboardScoreResponse, assertVerifyPurchaseRequest, assertVerifyPurchaseResponse, } from './types.js';
 export class InMemoryGameServicesStore {
     entitlementTransactionsByKey = new Map();
     entitlementTransactionsByEvidence = new Map();
@@ -622,6 +622,9 @@ function createStoredPurchaseRequest(request, transaction) {
     const purchasedAt = transaction.payload.purchasedAt;
     return {
         ...request,
+        // Evidence recovery can arrive with another request key. Consume/release must use the
+        // original durable grant generation, never the retry's newly supplied key.
+        idempotencyKey: transaction.idempotencyKey,
         ...(typeof platformTransactionId === 'string' && platformTransactionId.length > 0
             ? { platformTransactionId }
             : {}),
@@ -1157,5 +1160,5 @@ function applyCorsHeaders(headers, corsHeaders) {
         headers.set(key, value);
     }
 }
-export * from './notification-delivery';
-export * from './progress-link';
+export * from './notification-delivery.js';
+export * from './progress-link.js';

package/dist/verified-leaderboard-conformance.d.ts

@@ -1,4 +1,4 @@
-import { type VerifiedLeaderboardService } from './verified-leaderboard';
+import { type VerifiedLeaderboardService } from './verified-leaderboard.js';
 export declare const verifiedLeaderboardConformanceScenarios: readonly ['first-selection-and-snapshot', 'best-selection-and-retry', 'deterministic-ties', 'identity-and-definition-conflicts', 'concurrent-idempotency', 'mutation-isolation', 'runtime-validation'];
 export type VerifiedLeaderboardConformanceScenario = (typeof verifiedLeaderboardConformanceScenarios)[number];
 export interface CreateVerifiedLeaderboardConformanceFixtureInput {

package/dist/verified-leaderboard-conformance.js

@@ -1,4 +1,4 @@
-import { assertRecordVerifiedLeaderboardAttemptResponse, assertVerifiedLeaderboardSnapshot, } from './verified-leaderboard';
+import { assertRecordVerifiedLeaderboardAttemptResponse, assertVerifiedLeaderboardSnapshot, } from './verified-leaderboard.js';
 export const verifiedLeaderboardConformanceScenarios = [
     'first-selection-and-snapshot',
     'best-selection-and-retry',

package/dist/verified-leaderboard-durability-conformance.d.ts

@@ -1,4 +1,4 @@
-import { type VerifiedLeaderboardService } from './verified-leaderboard';
+import { type VerifiedLeaderboardService } from './verified-leaderboard.js';
 export declare const verifiedLeaderboardDurabilityConformanceScenarios: readonly ['replacement-after-interrupted-retained-write', 'concurrent-retry-after-interrupted-retained-write', 'snapshot-after-interrupted-retained-write'];
 export type VerifiedLeaderboardDurabilityConformanceScenario = (typeof verifiedLeaderboardDurabilityConformanceScenarios)[number];
 export interface CreateVerifiedLeaderboardDurabilityConformanceFixtureInput {