@mpgd/game-services 0.16.0 → 0.17.1

package/dist/monetization-recovery.js

@@ -0,0 +1,632 @@
+import { isAuthoritativeMicrosoftStoreCompletion } from './authoritative-purchase.js';
+import { createGameServicesClient } from './client.js';
+import { isClientRewardEvidence, resolveRewardPlatformImpressionId, } from './admob-client-reward.js';
+import { forwardGameServicesProgress, observeGameServicesOperation, } from './operation-progress.js';
+/**
+ * Client-side recovery coordinates UI callbacks and authoritative backend calls.
+ * It never grants a wallet locally. Journal evidence can contain receipts/tokens,
+ * so the game's durable store must encrypt and access-control its records.
+ */
+export function createRecoverableMonetizationClient(input) {
+    const store = input.operationStore;
+    const observedAt = () => input.now?.() ?? new Date().toISOString();
+    const inFlight = new Map();
+    const unjournaledPurchases = new Map();
+    const unjournaledRewards = new Map();
+    const unjournaledPurchaseResponses = new Map();
+    const unjournaledRewardResponses = new Map();
+    const unjournaledPurchaseResults = new Map();
+    const unjournaledRewardResults = new Map();
+    async function serializeOperation(key, task) {
+        const previous = inFlight.get(key) ?? Promise.resolve();
+        const running = previous.catch(() => undefined).then(task);
+        inFlight.set(key, running);
+        try {
+            return await running;
+        }
+        finally {
+            if (inFlight.get(key) === running) {
+                inFlight.delete(key);
+            }
+        }
+    }
+    async function save(record, patch) {
+        const next = { ...record, ...patch, revision: record.revision + 1 };
+        await store.replace(record.revision, next);
+        return next;
+    }
+    function assertOwner(record, kind, idempotencyKey, subjectId) {
+        if (record.key !== operationKey(input.target, kind, idempotencyKey)
+            || record.kind !== kind || record.playerId !== input.playerId
+            || record.target !== input.target
+            || record.deploymentTarget !== (input.deploymentTarget ?? input.target)
+            || record.input.idempotencyKey !== idempotencyKey
+            || (record.kind === 'purchase' ? record.input.productId : record.input.placementId)
+                !== subjectId) {
+            throw new Error('Monetization operation key is bound to another player or subject.');
+        }
+    }
+    async function purchase(operation, options) {
+        const key = operationKey(input.target, 'purchase', operation.idempotencyKey);
+        return serializeOperation(key, async () => {
+            const reserved = await store.reserve({
+                key,
+                kind: 'purchase',
+                playerId: input.playerId,
+                target: input.target,
+                deploymentTarget: input.deploymentTarget ?? input.target,
+                revision: 0,
+                input: operation,
+            });
+            if (reserved.record.kind !== 'purchase') {
+                throw new Error('Monetization operation kind conflicts with its journal key.');
+            }
+            assertOwner(reserved.record, 'purchase', operation.idempotencyKey, operation.productId);
+            if (reserved.record.input.source !== operation.source) {
+                throw new Error('Purchase idempotency key was reused for another source.');
+            }
+            return resumePurchase(reserved.record, reserved.created, options);
+        });
+    }
+    async function claimRewardedAd(operation, options) {
+        const key = operationKey(input.target, 'rewarded-ad', operation.idempotencyKey);
+        return serializeOperation(key, async () => {
+            const reserved = await store.reserve({
+                key,
+                kind: 'rewarded-ad',
+                playerId: input.playerId,
+                target: input.target,
+                deploymentTarget: input.deploymentTarget ?? input.target,
+                revision: 0,
+                input: operation,
+            });
+            if (reserved.record.kind !== 'rewarded-ad') {
+                throw new Error('Monetization operation kind conflicts with its journal key.');
+            }
+            assertOwner(reserved.record, 'rewarded-ad', operation.idempotencyKey, operation.placementId);
+            return resumeReward(reserved.record, reserved.created, options);
+        });
+    }
+    async function resumePurchase(initial, mayOpenPlatform = false, options) {
+        // Observe recovery once, so a journal failure resolved into a result still completes.
+        return observeGameServicesOperation('purchase', options, (progress) => {
+            return settlePurchase(initial, mayOpenPlatform, progress);
+        });
+    }
+    async function settlePurchase(initial, mayOpenPlatform, progress) {
+        let record = initial;
+        const unsavedResponse = unjournaledPurchaseResponses.get(record.key);
+        if (unsavedResponse !== undefined && record.response?.verified !== true) {
+            // A result beside the non-grant response is stale, such as another runtime's rejection.
+            // Drop it in the same write so the client path derives this grant again.
+            const { result: staleResult, ...current } = record;
+            try {
+                record = await save(current, { response: unsavedResponse });
+                unjournaledPurchaseResponses.delete(record.key);
+            }
+            catch {
+                return recordedPurchaseGrant({ ...current, response: unsavedResponse })
+                    ?? pendingPurchase(record.platform);
+            }
+        }
+        else if (record.response?.verified === true) {
+            unjournaledPurchaseResponses.delete(record.key);
+        }
+        const unsavedResult = unjournaledPurchaseResults.get(record.key);
+        if (unsavedResult !== undefined && record.result?.status !== 'granted') {
+            try {
+                record = await save(record, { result: unsavedResult });
+                unjournaledPurchaseResults.delete(record.key);
+            }
+            catch {
+                return unsavedResult;
+            }
+        }
+        else if (record.result?.status === 'granted') {
+            unjournaledPurchaseResults.delete(record.key);
+        }
+        const unjournaled = unjournaledPurchases.get(record.key);
+        if (unjournaled !== undefined && (record.platform === undefined
+            || record.platform.status === 'pending' && unjournaled.platform.status !== 'pending')) {
+            try {
+                record = await save(record, {
+                    platform: unjournaled.platform,
+                    platformCompletedAt: unjournaled.completedAt,
+                });
+                unjournaledPurchases.delete(record.key);
+            }
+            catch {
+                return recordedPurchaseGrant({ ...record, platform: unjournaled.platform })
+                    ?? pendingPurchase(unjournaled.platform);
+            }
+        }
+        else if (record.platform !== undefined) {
+            if (unjournaled !== undefined && !samePlatformResult(record.platform, unjournaled.platform)) {
+                throw new Error('A platform purchase callback conflicts with the recorded operation.');
+            }
+            unjournaledPurchases.delete(record.key);
+        }
+        const completed = record.result;
+        if (completed !== undefined && !purchaseNeedsRetry(record)) {
+            return completed;
+        }
+        if (record.request !== undefined) {
+            assertPurchaseRequest(record, input);
+        }
+        if (record.platform === undefined && !mayOpenPlatform) {
+            return pendingPurchase();
+        }
+        const client = createGameServicesClient({
+            ...input,
+            requestNow: () => record.platformCompletedAt ?? observedAt(),
+            gateway: {
+                ...input.gateway,
+                commerce: {
+                    ...input.gateway.commerce,
+                    async purchase(request) {
+                        if (record.platform !== undefined) {
+                            return record.platform;
+                        }
+                        const platform = await input.gateway.commerce.purchase(request);
+                        const completedAt = observedAt();
+                        const prior = record;
+                        record = { ...record, platform, platformCompletedAt: completedAt };
+                        try {
+                            record = await save(prior, { platform, platformCompletedAt: completedAt });
+                        }
+                        catch (error) {
+                            unjournaledPurchases.set(record.key, { platform, completedAt });
+                            throw error;
+                        }
+                        return platform;
+                    },
+                },
+            },
+            backend: {
+                ...input.backend,
+                purchases: {
+                    async verifyPurchase(request) {
+                        if (record.request === undefined) {
+                            record = await save(record, { request });
+                        }
+                        const recordedRequest = record.request;
+                        if (recordedRequest === undefined) {
+                            throw new Error('Purchase request was not journaled before backend dispatch.');
+                        }
+                        let response;
+                        try {
+                            response = await input.backend.purchases.verifyPurchase(recordedRequest);
+                        }
+                        catch {
+                            if (record.response?.verified === true) {
+                                return record.response;
+                            }
+                            return {
+                                verified: false,
+                                alreadyProcessed: false,
+                                disposition: 'pending',
+                                reason: 'BACKEND_UNAVAILABLE',
+                            };
+                        }
+                        if (record.response?.verified === true && !response.verified) {
+                            return record.response;
+                        }
+                        const prior = record;
+                        record = { ...record, response };
+                        try {
+                            record = await save(prior, { response });
+                            unjournaledPurchaseResponses.delete(record.key);
+                        }
+                        catch (error) {
+                            if (response.verified) {
+                                unjournaledPurchaseResponses.set(record.key, response);
+                            }
+                            throw error;
+                        }
+                        return response;
+                    },
+                },
+            },
+        });
+        try {
+            const result = await client.purchase(record.input, forwardGameServicesProgress(progress));
+            if (result.status === 'granted') {
+                unjournaledPurchaseResults.set(record.key, result);
+            }
+            record = await save(record, { result });
+            unjournaledPurchaseResults.delete(record.key);
+            return result;
+        }
+        catch {
+            // No UI retry is safe after a possibly completed platform callback.
+            return recordedPurchaseGrant(record)
+                ?? unjournaledPurchaseResults.get(record.key)
+                ?? pendingPurchase(record.platform);
+        }
+    }
+    async function resumeReward(initial, mayOpenPlatform = false, options) {
+        return observeGameServicesOperation('rewarded-ad', options, (progress) => {
+            return settleReward(initial, mayOpenPlatform, progress);
+        });
+    }
+    async function settleReward(initial, mayOpenPlatform, progress) {
+        let record = initial;
+        const unsavedResponse = unjournaledRewardResponses.get(record.key);
+        if (unsavedResponse !== undefined && record.response?.granted !== true) {
+            // A result beside the non-grant claim is stale, such as another runtime's rejection.
+            // Drop it in the same write so the client path derives this grant again.
+            const { result: staleResult, ...current } = record;
+            try {
+                record = await save(current, { response: unsavedResponse });
+                unjournaledRewardResponses.delete(record.key);
+            }
+            catch {
+                return recordedRewardGrant({ ...current, response: unsavedResponse })
+                    ?? pendingReward(record.platform);
+            }
+        }
+        else if (record.response?.granted === true) {
+            unjournaledRewardResponses.delete(record.key);
+        }
+        const unsavedResult = unjournaledRewardResults.get(record.key);
+        if (unsavedResult !== undefined && record.result?.status !== 'granted') {
+            try {
+                record = await save(record, { result: unsavedResult });
+                unjournaledRewardResults.delete(record.key);
+            }
+            catch {
+                return unsavedResult;
+            }
+        }
+        else if (record.result?.status === 'granted') {
+            unjournaledRewardResults.delete(record.key);
+        }
+        const unjournaled = unjournaledRewards.get(record.key);
+        if (unjournaled !== undefined && (record.platform === undefined
+            || record.platform.status === 'pending' && unjournaled.platform.status !== 'pending')) {
+            try {
+                record = await save(record, {
+                    platform: unjournaled.platform,
+                    platformCompletedAt: unjournaled.completedAt,
+                });
+                unjournaledRewards.delete(record.key);
+            }
+            catch {
+                return pendingReward(unjournaled.platform);
+            }
+        }
+        else if (record.platform !== undefined) {
+            if (unjournaled !== undefined && !samePlatformResult(record.platform, unjournaled.platform)) {
+                throw new Error('A platform ad callback conflicts with the recorded operation.');
+            }
+            unjournaledRewards.delete(record.key);
+        }
+        const completed = record.result;
+        if (completed !== undefined && completed.status !== 'pending') {
+            return completed;
+        }
+        if (record.request !== undefined) {
+            assertRewardRequest(record, input);
+        }
+        if (record.platform === undefined && !mayOpenPlatform) {
+            return pendingReward();
+        }
+        const client = createGameServicesClient({
+            ...input,
+            requestNow: () => record.platformCompletedAt ?? observedAt(),
+            gateway: {
+                ...input.gateway,
+                ads: {
+                    ...input.gateway.ads,
+                    async showRewarded(request) {
+                        if (record.platform !== undefined) {
+                            return record.platform;
+                        }
+                        const platform = await input.gateway.ads.showRewarded(request);
+                        const completedAt = observedAt();
+                        const prior = record;
+                        record = { ...record, platform, platformCompletedAt: completedAt };
+                        try {
+                            record = await save(prior, { platform, platformCompletedAt: completedAt });
+                        }
+                        catch (error) {
+                            unjournaledRewards.set(record.key, { platform, completedAt });
+                            throw error;
+                        }
+                        return platform;
+                    },
+                },
+            },
+            backend: {
+                ...input.backend,
+                adRewards: {
+                    async claimAdReward(request) {
+                        if (record.request === undefined) {
+                            record = await save(record, { request });
+                        }
+                        const recordedRequest = record.request;
+                        if (recordedRequest === undefined) {
+                            throw new Error('Reward claim was not journaled before backend dispatch.');
+                        }
+                        let response;
+                        try {
+                            response = await input.backend.adRewards.claimAdReward(recordedRequest);
+                        }
+                        catch {
+                            if (record.response?.granted === true) {
+                                return record.response;
+                            }
+                            return {
+                                granted: false,
+                                alreadyProcessed: false,
+                                disposition: 'pending',
+                                reason: 'BACKEND_UNAVAILABLE',
+                            };
+                        }
+                        if (record.response?.granted === true && !response.granted) {
+                            return record.response;
+                        }
+                        const prior = record;
+                        record = { ...record, response };
+                        try {
+                            record = await save(prior, { response });
+                            unjournaledRewardResponses.delete(record.key);
+                        }
+                        catch (error) {
+                            if (response.granted) {
+                                unjournaledRewardResponses.set(record.key, response);
+                            }
+                            throw error;
+                        }
+                        return response;
+                    },
+                },
+            },
+        });
+        try {
+            const result = await client.claimRewardedAd(record.input, forwardGameServicesProgress(progress));
+            if (result.status === 'granted') {
+                unjournaledRewardResults.set(record.key, result);
+            }
+            record = await save(record, { result });
+            unjournaledRewardResults.delete(record.key);
+            return result;
+        }
+        catch {
+            return recordedRewardGrant(record)
+                ?? unjournaledRewardResults.get(record.key)
+                ?? pendingReward(record.platform);
+        }
+    }
+    async function recoverPurchaseResult(idempotencyKey, platform) {
+        const key = operationKey(input.target, 'purchase', idempotencyKey);
+        return serializeOperation(key, async () => {
+            const found = await store.read(key);
+            if (found?.kind !== 'purchase') {
+                throw new Error('No reserved purchase operation matches this platform callback.');
+            }
+            assertOwner(found, 'purchase', idempotencyKey, found.input.productId);
+            const transient = unjournaledPurchases.get(key);
+            if (transient !== undefined && !samePlatformResult(transient.platform, platform)
+                && !(transient.platform.status === 'pending' && platform.status !== 'pending')) {
+                throw new Error('A platform purchase callback conflicts with the unjournaled result.');
+            }
+            const canAdvance = found.platform?.status === 'pending'
+                && platform.status !== 'pending' && found.request === undefined;
+            if (found.platform !== undefined && !samePlatformResult(found.platform, platform)
+                && !canAdvance) {
+                throw new Error('A platform purchase callback conflicts with the recorded operation.');
+            }
+            let record = found;
+            if (found.platform === undefined || canAdvance) {
+                const completedAt = observedAt();
+                try {
+                    record = await save(found, { platform, platformCompletedAt: completedAt });
+                }
+                catch {
+                    unjournaledPurchases.set(key, { platform, completedAt });
+                    return recordedPurchaseGrant({ ...found, platform }) ?? pendingPurchase(platform);
+                }
+            }
+            unjournaledPurchases.delete(key);
+            return resumePurchase(record);
+        });
+    }
+    async function recoverRewardResult(idempotencyKey, platform) {
+        const key = operationKey(input.target, 'rewarded-ad', idempotencyKey);
+        return serializeOperation(key, async () => {
+            const found = await store.read(key);
+            if (found?.kind !== 'rewarded-ad') {
+                throw new Error('No reserved rewarded-ad operation matches this platform callback.');
+            }
+            assertOwner(found, 'rewarded-ad', idempotencyKey, found.input.placementId);
+            const transient = unjournaledRewards.get(key);
+            if (transient !== undefined && !samePlatformResult(transient.platform, platform)
+                && !(transient.platform.status === 'pending' && platform.status !== 'pending')) {
+                throw new Error('A platform ad callback conflicts with the unjournaled result.');
+            }
+            const canAdvance = found.platform?.status === 'pending'
+                && platform.status !== 'pending' && found.request === undefined;
+            if (found.platform !== undefined && !samePlatformResult(found.platform, platform)
+                && !canAdvance) {
+                throw new Error('A platform ad callback conflicts with the recorded operation.');
+            }
+            let record = found;
+            if (found.platform === undefined || canAdvance) {
+                const completedAt = observedAt();
+                try {
+                    record = await save(found, { platform, platformCompletedAt: completedAt });
+                }
+                catch {
+                    unjournaledRewards.set(key, { platform, completedAt });
+                    return pendingReward(platform);
+                }
+            }
+            unjournaledRewards.delete(key);
+            return resumeReward(record);
+        });
+    }
+    async function reconcile() {
+        const pending = await store.listRecoverable(input.playerId);
+        const summaries = [];
+        for (const record of pending) {
+            if (record?.playerId !== input.playerId || record.target !== input.target
+                || record.deploymentTarget !== (input.deploymentTarget ?? input.target)) {
+                continue;
+            }
+            if (record.kind !== 'purchase' && record.kind !== 'rewarded-ad') {
+                continue;
+            }
+            const idempotencyKey = typeof record.input?.idempotencyKey === 'string'
+                ? record.input.idempotencyKey
+                : 'unreadable-operation';
+            if (inFlight.has(record.key)) {
+                continue;
+            }
+            try {
+                const summary = await serializeOperation(record.key, async () => {
+                    let latest;
+                    try {
+                        latest = await store.read(record.key) ?? record;
+                    }
+                    catch {
+                        throw new OperationReadError();
+                    }
+                    assertOwner(latest, latest.kind, latest.input.idempotencyKey, latest.kind === 'purchase' ? latest.input.productId : latest.input.placementId);
+                    if (latest.kind === 'purchase') {
+                        const result = await resumePurchase(latest);
+                        return {
+                            kind: latest.kind,
+                            idempotencyKey: latest.input.idempotencyKey,
+                            status: result.status,
+                            finalizationPending: result.verification?.finalization?.status === 'pending',
+                        };
+                    }
+                    const result = await resumeReward(latest);
+                    return {
+                        kind: latest.kind,
+                        idempotencyKey: latest.input.idempotencyKey,
+                        status: result.status,
+                        finalizationPending: false,
+                    };
+                });
+                summaries.push(summary);
+            }
+            catch (error) {
+                summaries.push({
+                    kind: record.kind,
+                    idempotencyKey,
+                    status: error instanceof OperationReadError ? 'pending' : 'action-required',
+                    finalizationPending: false,
+                });
+            }
+        }
+        return summaries;
+    }
+    return { purchase, claimRewardedAd, recoverPurchaseResult, recoverRewardResult, reconcile };
+}
+class OperationReadError extends Error {
+}
+function operationKey(target, kind, idempotencyKey) {
+    if (idempotencyKey.trim() === '') {
+        throw new Error('Monetization operations require a nonempty idempotency key.');
+    }
+    return JSON.stringify([target, kind, idempotencyKey]);
+}
+function samePlatformResult(left, right) {
+    return JSON.stringify(canonicalJson(left)) === JSON.stringify(canonicalJson(right));
+}
+function canonicalJson(value) {
+    if (Array.isArray(value)) {
+        return value.map(canonicalJson);
+    }
+    if (value !== null && typeof value === 'object') {
+        const entries = Object.entries(value)
+            .filter(([, entry]) => entry !== undefined)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => [key, canonicalJson(entry)]);
+        return Object.fromEntries(entries);
+    }
+    return value;
+}
+function pendingPurchase(platform) {
+    return {
+        status: 'pending',
+        purchase: platform ?? { status: 'pending', entitlementIds: [] },
+    };
+}
+function pendingReward(platform) {
+    return {
+        status: 'pending',
+        reward: platform ?? { status: 'pending', rewardGranted: false },
+    };
+}
+function recordedPurchaseGrant(record) {
+    if (record.result?.status === 'granted') {
+        return record.result;
+    }
+    if (record.platform !== undefined
+        && isAuthoritativeMicrosoftStoreCompletion(record.target, record.platform)) {
+        // The adapter completed this ledger grant before returning, as the client path reports it.
+        return {
+            status: 'granted',
+            purchase: record.platform,
+            ledgerEntryId: record.platform.transactionId,
+        };
+    }
+    if (record.response?.verified !== true || record.platform === undefined) {
+        return undefined;
+    }
+    return {
+        status: 'granted',
+        purchase: record.platform,
+        verification: record.response,
+        ...(record.response.ledgerEntryId === undefined
+            ? {} : { ledgerEntryId: record.response.ledgerEntryId }),
+    };
+}
+function recordedRewardGrant(record) {
+    if (record.result?.status === 'granted') {
+        return record.result;
+    }
+    if (record.response?.granted !== true || record.platform === undefined) {
+        return undefined;
+    }
+    return {
+        status: 'granted',
+        reward: record.platform,
+        claim: record.response,
+        ...(record.response.ledgerEntryId === undefined
+            ? {} : { ledgerEntryId: record.response.ledgerEntryId }),
+    };
+}
+function purchaseNeedsRetry(record) {
+    return record.result?.status === 'pending'
+        || record.response?.finalization?.status === 'pending';
+}
+function assertPurchaseRequest(record, input) {
+    const request = record.request;
+    if (request === undefined || record.platform?.status !== 'completed'
+        || request.playerId !== record.playerId || request.playerId !== input.playerId
+        || request.target !== record.target || request.productId !== record.input.productId
+        || request.idempotencyKey !== record.input.idempotencyKey
+        || request.platformTransactionId !== record.platform.transactionId
+        || request.deploymentTarget !== (input.deploymentTarget === input.target
+            ? undefined : input.deploymentTarget)) {
+        throw new Error('Journaled purchase verification is not bound to its platform result.');
+    }
+}
+function assertRewardRequest(record, input) {
+    const request = record.request;
+    if (request === undefined || record.platform === undefined
+        || ((record.platform.status !== 'completed' || !record.platform.rewardGranted)
+            && !isClientRewardEvidence(record.platform))
+        || request.playerId !== record.playerId || request.playerId !== input.playerId
+        || request.target !== record.target || request.placementId !== record.input.placementId
+        || request.idempotencyKey !== record.input.idempotencyKey
+        || request.platformImpressionId !== resolveRewardPlatformImpressionId(record.platform)
+        || request.deploymentTarget !== (input.deploymentTarget === input.target
+            ? undefined : input.deploymentTarget)) {
+        throw new Error('Journaled ad claim is not bound to its platform result.');
+    }
+}

package/dist/operation-progress.d.ts

@@ -36,12 +36,18 @@ export interface GameServicesOperationOptions<TProgress = GameServicesOperationP
   readonly onObserverError?: (error: unknown) => void | Promise<void>;
   readonly correlationId?: string;
 }
-interface OperationReporter<K extends GameServicesOperationKind> {
+export interface OperationReporter<K extends GameServicesOperationKind> {
   platformRequested(): void;
   platformResult(status: PlatformStatus<K>): void;
   serverRequested(): void;
   serverResult(accepted: boolean): void;
 }
+/**
+* Internal: relay a nested operation's platform and server phases to an outer observation.
+* Its `completed` and `exception` stay internal because the outer observation reports the
+* outcome it actually returns.
+*/
+export declare function forwardGameServicesProgress<K extends GameServicesOperationKind>(reporter: OperationReporter<K>): GameServicesOperationOptions<OperationProgress<K>>;
 /** 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

@@ -1,3 +1,26 @@
+/**
+ * Internal: relay a nested operation's platform and server phases to an outer observation.
+ * Its `completed` and `exception` stay internal because the outer observation reports the
+ * outcome it actually returns.
+ */
+export function forwardGameServicesProgress(reporter) {
+    return {
+        onProgress(progress) {
+            if (progress.phase === 'platform-requested') {
+                reporter.platformRequested();
+            }
+            else if (progress.phase === 'platform-result') {
+                reporter.platformResult(progress.status);
+            }
+            else if (progress.phase === 'server-requested') {
+                reporter.serverRequested();
+            }
+            else if (progress.phase === 'server-result') {
+                reporter.serverResult(progress.accepted);
+            }
+        },
+    };
+}
 /** Internal observation wrapper; it does not retry, cancel, verify, or grant anything. */
 export async function observeGameServicesOperation(kind, options, operation) {
     let onProgress;