@mpgd/game-services 0.9.0 → 0.10.0

package/dist/apps-in-toss-evidence-verification-conformance.js

@@ -0,0 +1,613 @@
+import { appsInTossPurchaseCallbackEvidenceSchema, createAppsInTossProductGrantCallback, createAppsInTossProductGrantVerificationPort, createAppsInTossProductionEvidenceVerifier, createAppsInTossPurchaseCallbackEvidence, createAppsInTossRewardCallbackEvidence, } from './apps-in-toss-evidence-verification';
+import { createGameServicesBackend, createInMemoryGameServicesStore, InMemoryGameServicesStore, } from './server';
+export const appsInTossProductionEvidenceConformanceScenarios = [
+    'callback-only-fail-closed',
+    'purchase-product-grant-callback',
+    'purchase-authority-retry',
+    'purchase-pending-order-restore',
+    'purchase-authority-matching',
+    'purchase-timestamp-normalization',
+    'reward-authority-retry-and-replay',
+    'reward-timestamp-validation',
+    'authority-errors-and-reward-matching',
+];
+const catalog = {
+    version: 'conformance',
+    products: [
+        {
+            id: 'CONFORMANCE_COINS',
+            type: 'consumable',
+            grant: {
+                type: 'currency',
+                currency: 'coin',
+                amount: 10,
+            },
+            platformProductIds: {
+                ait: 'ait.conformance.coins',
+            },
+        },
+    ],
+};
+const placements = {
+    version: 'conformance',
+    placements: [
+        {
+            id: 'CONFORMANCE_REWARD',
+            type: 'rewarded',
+            reward: {
+                type: 'continue',
+                amount: 1,
+            },
+            frequencyCap: {
+                cooldownSeconds: 1,
+                maxPerSession: 1,
+            },
+            platformPlacementIds: {
+                ait: 'ait.conformance.reward',
+            },
+        },
+    ],
+};
+const scenarioRunners = {
+    'callback-only-fail-closed': runCallbackOnlyFailClosedScenario,
+    'purchase-product-grant-callback': runPurchaseProductGrantCallbackScenario,
+    'purchase-authority-retry': runPurchaseAuthorityRetryScenario,
+    'purchase-pending-order-restore': runPurchasePendingOrderRestoreScenario,
+    'purchase-authority-matching': runPurchaseAuthorityMatchingScenario,
+    'purchase-timestamp-normalization': runPurchaseTimestampNormalizationScenario,
+    'reward-authority-retry-and-replay': runRewardAuthorityRetryAndReplayScenario,
+    'reward-timestamp-validation': runRewardTimestampValidationScenario,
+    'authority-errors-and-reward-matching': runAuthorityErrorsAndRewardMatchingScenario,
+};
+/**
+ * Runs deterministic client-callback, authority, and ledger scenarios without
+ * requiring Apps in Toss credentials or platform SDK imports.
+ */
+export async function runAppsInTossProductionEvidenceConformance(input = {}) {
+    const createVerifier = input.createVerifier ?? createAppsInTossProductionEvidenceVerifier;
+    const now = input.now ?? '2030-01-02T03:04:05.000Z';
+    const passedScenarios = [];
+    for (const scenario of appsInTossProductionEvidenceConformanceScenarios) {
+        const runScenario = scenarioRunners[scenario];
+        try {
+            await runScenario(createVerifier, now);
+        }
+        catch (error) {
+            throw new Error(`Apps in Toss production evidence conformance failed: ${scenario}.`, {
+                cause: error,
+            });
+        }
+        passedScenarios.push(scenario);
+    }
+    return { passedScenarios };
+}
+export function createAppsInTossProductionEvidenceAuthorityFixture() {
+    const purchaseResults = [];
+    const rewardResults = [];
+    const purchaseInputs = [];
+    const rewardInputs = [];
+    return {
+        purchaseAuthority: {
+            async getOrderStatus(input) {
+                purchaseInputs.push(input);
+                return shiftFixtureResult(purchaseResults, {
+                    decision: 'rejected',
+                    reason: 'AIT_PURCHASE_AUTHORITY_FIXTURE_EXHAUSTED',
+                });
+            },
+        },
+        rewardAuthority: {
+            async verifyReward(input) {
+                rewardInputs.push(input);
+                return shiftFixtureResult(rewardResults, {
+                    decision: 'rejected',
+                    reason: 'AIT_REWARD_AUTHORITY_FIXTURE_EXHAUSTED',
+                });
+            },
+        },
+        enqueuePurchaseResult(result) {
+            purchaseResults.push(result);
+        },
+        enqueueRewardResult(result) {
+            rewardResults.push(result);
+        },
+        get purchaseInputs() {
+            return [...purchaseInputs];
+        },
+        get rewardInputs() {
+            return [...rewardInputs];
+        },
+    };
+}
+async function runCallbackOnlyFailClosedScenario(createVerifier, now) {
+    const context = createScenarioContext(createVerifier, now);
+    const purchase = await context.backend.purchases.verifyPurchase(purchaseRequest());
+    const reward = await context.backend.adRewards.claimAdReward(rewardRequest());
+    const postSuccessPurchase = await context.backend.purchases.verifyPurchase(purchaseRequest({
+        idempotencyKey: 'purchase-post-success',
+        evidence: {
+            schema: appsInTossPurchaseCallbackEvidenceSchema,
+            payload: {
+                orderId: 'ait-order-1',
+                sku: 'ait.conformance.coins',
+                source: 'success-event',
+            },
+        },
+    }));
+    assertEqual(purchase.verified, false, 'callback-only purchase must not grant');
+    assertEqual(purchase.reason, 'AIT_PURCHASE_AUTHORITY_UNAVAILABLE', 'callback-only purchase must identify the missing authority');
+    assertEqual(reward.granted, false, 'callback-only reward must not grant');
+    assertEqual(reward.reason, 'AIT_REWARD_AUTHORITY_UNAVAILABLE', 'callback-only reward must identify the missing authority');
+    assertEqual(postSuccessPurchase.reason, 'AIT_PURCHASE_CALLBACK_SOURCE_INVALID', 'post-success purchase evidence must never be grantable');
+    await assertEntitlementCount(context.store, 0, 'callback-only evidence');
+}
+async function runPurchaseAuthorityRetryScenario(createVerifier, now) {
+    const fixture = createAppsInTossProductionEvidenceAuthorityFixture();
+    fixture.enqueuePurchaseResult(resolvedOrder());
+    const context = createScenarioContext(createVerifier, now, {
+        purchaseAuthority: fixture.purchaseAuthority,
+    });
+    const request = purchaseRequest();
+    const first = await context.backend.purchases.verifyPurchase(request);
+    const retry = await context.backend.purchases.verifyPurchase(request);
+    assertEqual(first.verified, true, 'authority-confirmed purchase must grant');
+    assertEqual(first.alreadyProcessed, false, 'first purchase must be new');
+    assertEqual(retry.verified, true, 'same purchase retry must remain accepted');
+    assertEqual(retry.alreadyProcessed, true, 'same purchase retry must deduplicate');
+    assertEqual(fixture.purchaseInputs.length, 1, 'ledger retry must not re-query authority');
+    await assertEntitlementCount(context.store, 1, 'purchase retry');
+    const [transaction] = await context.store.listEntitlementTransactions();
+    assertEqual(transaction?.evidenceVerificationId, 'apps-in-toss:purchase:ait-order-1', 'purchase must persist the stable authority identity');
+}
+async function runPurchaseProductGrantCallbackScenario(createVerifier, now) {
+    const failClosedStore = new AbortAwareConformanceStore();
+    const failClosedContext = createScenarioContext(createVerifier, now, {}, failClosedStore);
+    const backendFailures = [];
+    const failClosedCallback = createAppsInTossProductGrantCallback({
+        purchaseVerification: createConformanceProductGrantVerificationPort((request, signal) => failClosedStore.runWithGrantSignal(signal, () => failClosedContext.backend.purchases.verifyPurchase(request))),
+        playerId: 'ait-player-1',
+        productId: 'CONFORMANCE_COINS',
+        platformSku: 'ait.conformance.coins',
+        onVerificationError: (error) => backendFailures.push(error),
+        now: () => now,
+    });
+    assertEqual(await failClosedCallback({ orderId: 'ait-order-fail-closed' }), false, 'product-grant callback must fail closed without authority');
+    assertEqual(backendFailures.length, 1, 'backend rejection must be observable');
+    assertEqual(backendFailures[0] instanceof Error
+        && backendFailures[0].message.includes('AIT_PURCHASE_AUTHORITY_UNAVAILABLE'), true, 'backend rejection diagnostics must retain the server reason');
+    const transportFailures = [];
+    const transportFailureCallback = createAppsInTossProductGrantCallback({
+        purchaseVerification: createAppsInTossProductGrantVerificationPort(async () => {
+            throw new Error('simulated callback transport failure');
+        }),
+        playerId: 'ait-player-1',
+        productId: 'CONFORMANCE_COINS',
+        platformSku: 'ait.conformance.coins',
+        onVerificationError: (error) => transportFailures.push(error),
+        now: () => now,
+    });
+    assertEqual(await transportFailureCallback({ orderId: 'ait-order-transport-failure' }), false, 'product-grant transport failure must return false to the SDK');
+    assertEqual(transportFailures.length, 1, 'product-grant failures must be observable');
+    const deadlineStore = new AbortAwareConformanceStore();
+    const deadlineSignals = [];
+    const deadlineAuthorityGate = createVoidDeferred();
+    const deadlineAuthorityStarted = createVoidDeferred();
+    const lateVerificationSettled = createVoidDeferred();
+    const deadlineContext = createScenarioContext(createVerifier, now, {
+        purchaseAuthority: {
+            async getOrderStatus() {
+                deadlineAuthorityStarted.resolve();
+                await deadlineAuthorityGate.promise;
+                return resolvedOrder({ orderId: 'ait-order-deadline' });
+            },
+        },
+    }, deadlineStore);
+    const deadlineCallback = createAppsInTossProductGrantCallback({
+        purchaseVerification: createConformanceProductGrantVerificationPort(async (request, signal) => {
+            deadlineSignals.push(signal);
+            try {
+                return await deadlineStore.runWithGrantSignal(signal, () => deadlineContext.backend.purchases.verifyPurchase(request));
+            }
+            finally {
+                lateVerificationSettled.resolve();
+            }
+        }),
+        playerId: 'ait-player-1',
+        productId: 'CONFORMANCE_COINS',
+        platformSku: 'ait.conformance.coins',
+        timeoutMs: 1,
+        now: () => now,
+    });
+    const deadlineResult = deadlineCallback({ orderId: 'ait-order-deadline' });
+    await deadlineAuthorityStarted.promise;
+    assertEqual(await deadlineResult, false, 'product-grant deadline must return false to the SDK');
+    assertEqual(deadlineSignals[0]?.aborted, true, 'product-grant deadline must abort transport');
+    deadlineAuthorityGate.resolve();
+    await lateVerificationSettled.promise;
+    await assertEntitlementCount(deadlineStore, 0, 'aborted late product grant');
+    await assertEntitlementCount(failClosedContext.store, 0, 'fail-closed product-grant callback');
+    const fixture = createAppsInTossProductionEvidenceAuthorityFixture();
+    fixture.enqueuePurchaseResult(resolvedOrder());
+    const store = new AbortAwareConformanceStore();
+    const context = createScenarioContext(createVerifier, now, { purchaseAuthority: fixture.purchaseAuthority }, store);
+    const callback = createAppsInTossProductGrantCallback({
+        purchaseVerification: createConformanceProductGrantVerificationPort((request, signal) => store.runWithGrantSignal(signal, () => context.backend.purchases.verifyPurchase(request))),
+        playerId: 'ait-player-1',
+        productId: 'CONFORMANCE_COINS',
+        platformSku: 'ait.conformance.coins',
+        now: () => now,
+    });
+    assertEqual(await callback({ orderId: 'ait-order-1' }), true, 'product-grant callback must wait for an authoritative ledger grant');
+    await assertEntitlementCount(context.store, 1, 'authoritative product-grant callback');
+    const [transaction] = await context.store.listEntitlementTransactions();
+    assertEqual(transaction?.idempotencyKey, 'apps-in-toss:purchase:ait-order-1', 'product-grant callback must derive restart-stable order idempotency');
+}
+async function runPurchasePendingOrderRestoreScenario(createVerifier, now) {
+    const fixture = createAppsInTossProductionEvidenceAuthorityFixture();
+    fixture.enqueuePurchaseResult(new Error('simulated partner-server failure'));
+    fixture.enqueuePurchaseResult(resolvedOrder({ status: 'PAYMENT_COMPLETED' }));
+    const context = createScenarioContext(createVerifier, now, {
+        purchaseAuthority: fixture.purchaseAuthority,
+    });
+    const initial = await context.backend.purchases.verifyPurchase(purchaseRequest());
+    const restored = await context.backend.purchases.verifyPurchase(purchaseRequest({
+        evidence: createAppsInTossPurchaseCallbackEvidence({
+            orderId: 'ait-order-1',
+            platformSku: 'ait.conformance.coins',
+            source: 'pending-order-restore',
+        }),
+    }));
+    assertEqual(initial.verified, false, 'server failure must not grant');
+    assertEqual(initial.reason, 'AIT_PURCHASE_AUTHORITY_ERROR', 'server failure must surface as a purchase authority failure');
+    assertEqual(restored.verified, true, 'restored payment-completed order must grant');
+    assertEqual(restored.alreadyProcessed, false, 'restored order must create one grant');
+    await assertEntitlementCount(context.store, 1, 'pending order restore');
+    const [transaction] = await context.store.listEntitlementTransactions();
+    assertEqual(transaction?.payload.appsInTossOrderStatus, 'PAYMENT_COMPLETED', 'restore must retain the authoritative order status');
+    assertEqual(transaction?.payload.appsInTossGrantCompletionRequired, true, 'payment-completed recovery must require SDK grant completion');
+}
+async function runPurchaseAuthorityMatchingScenario(createVerifier, now) {
+    const fixture = createAppsInTossProductionEvidenceAuthorityFixture();
+    fixture.enqueuePurchaseResult(resolvedOrder({ orderId: 'different-order' }));
+    fixture.enqueuePurchaseResult(resolvedOrder({ playerId: 'different-player' }));
+    fixture.enqueuePurchaseResult(resolvedOrder({
+        orderId: 'ait-order-sku',
+        sku: 'different-sku',
+    }));
+    fixture.enqueuePurchaseResult(resolvedOrder({
+        orderId: 'ait-order-refunded',
+        status: 'REFUNDED',
+    }));
+    fixture.enqueuePurchaseResult(resolvedOrder({
+        orderId: 'ait-order-progress',
+        status: 'ORDER_IN_PROGRESS',
+    }));
+    const context = createScenarioContext(createVerifier, now, {
+        purchaseAuthority: fixture.purchaseAuthority,
+    });
+    const orderMismatch = await context.backend.purchases.verifyPurchase(purchaseRequest());
+    const playerMismatch = await context.backend.purchases.verifyPurchase(purchaseRequest({ idempotencyKey: 'purchase-player' }));
+    const skuMismatch = await context.backend.purchases.verifyPurchase(purchaseRequest({
+        platformTransactionId: 'ait-order-sku',
+        idempotencyKey: 'purchase-sku',
+        evidence: purchaseEvidence('ait-order-sku'),
+    }));
+    const refunded = await context.backend.purchases.verifyPurchase(purchaseRequest({
+        platformTransactionId: 'ait-order-refunded',
+        idempotencyKey: 'purchase-refunded',
+        evidence: purchaseEvidence('ait-order-refunded'),
+    }));
+    const progress = await context.backend.purchases.verifyPurchase(purchaseRequest({
+        platformTransactionId: 'ait-order-progress',
+        idempotencyKey: 'purchase-progress',
+        evidence: purchaseEvidence('ait-order-progress'),
+    }));
+    assertEqual(orderMismatch.reason, 'AIT_PURCHASE_AUTHORITY_ORDER_ID_MISMATCH', 'purchase order identifier mismatch');
+    assertEqual(playerMismatch.reason, 'AIT_PURCHASE_AUTHORITY_PLAYER_MISMATCH', 'purchase player mismatch');
+    assertEqual(skuMismatch.reason, 'AIT_PURCHASE_AUTHORITY_SKU_MISMATCH', 'purchase sku mismatch');
+    assertEqual(refunded.reason, 'AIT_PURCHASE_ORDER_REFUNDED', 'refunded purchase');
+    assertEqual(progress.reason, 'AIT_PURCHASE_ORDER_ORDER_IN_PROGRESS', 'in-progress purchase');
+    await assertEntitlementCount(context.store, 0, 'purchase mismatches and status');
+}
+async function runPurchaseTimestampNormalizationScenario(createVerifier, now) {
+    const fixture = createAppsInTossProductionEvidenceAuthorityFixture();
+    fixture.enqueuePurchaseResult(resolvedOrder({
+        orderId: 'ait-order-kst',
+        statusDeterminedAt: '2025-09-12T16:57:12',
+    }));
+    fixture.enqueuePurchaseResult(resolvedOrder({
+        orderId: 'ait-order-invalid-date',
+        statusDeterminedAt: '2025-02-30T16:57:12',
+    }));
+    const context = createScenarioContext(createVerifier, now, {
+        purchaseAuthority: fixture.purchaseAuthority,
+    });
+    const kstOrder = await context.backend.purchases.verifyPurchase(purchaseRequest({
+        platformTransactionId: 'ait-order-kst',
+        idempotencyKey: 'purchase-kst',
+        evidence: purchaseEvidence('ait-order-kst'),
+    }));
+    const invalidDate = await context.backend.purchases.verifyPurchase(purchaseRequest({
+        platformTransactionId: 'ait-order-invalid-date',
+        idempotencyKey: 'purchase-invalid-date',
+        evidence: purchaseEvidence('ait-order-invalid-date'),
+    }));
+    assertEqual(kstOrder.verified, true, 'documented KST timestamp must verify deterministically');
+    assertEqual(invalidDate.reason, 'AIT_PURCHASE_AUTHORITY_TIMESTAMP_INVALID', 'calendar-overflow timestamp must be rejected');
+    const [transaction] = await context.store.listEntitlementTransactions();
+    assertEqual(transaction?.payload.evidenceVerifiedAt, '2025-09-12T07:57:12.000Z', 'offset-free order timestamps must normalize as documented KST');
+    await assertEntitlementCount(context.store, 1, 'deterministic timestamp normalization');
+}
+async function runRewardAuthorityRetryAndReplayScenario(createVerifier, now) {
+    const fixture = createAppsInTossProductionEvidenceAuthorityFixture();
+    fixture.enqueueRewardResult(verifiedReward());
+    fixture.enqueueRewardResult(verifiedReward());
+    const context = createScenarioContext(createVerifier, now, {
+        rewardAuthority: fixture.rewardAuthority,
+    });
+    const request = rewardRequest();
+    const first = await context.backend.adRewards.claimAdReward(request);
+    const retry = await context.backend.adRewards.claimAdReward(request);
+    const replay = await context.backend.adRewards.claimAdReward({
+        ...request,
+        idempotencyKey: 'reward-replay',
+    });
+    assertEqual(first.granted, true, 'authority-confirmed reward must grant');
+    assertEqual(first.alreadyProcessed, false, 'first reward must be new');
+    assertEqual(retry.granted, true, 'same reward retry must remain accepted');
+    assertEqual(retry.alreadyProcessed, true, 'same reward retry must deduplicate');
+    assertEqual(replay.granted, false, 'replayed authority evidence must not grant');
+    assertEqual(replay.reason, 'EVIDENCE_ALREADY_PROCESSED', 'replayed authority evidence must be rejected explicitly');
+    assertEqual(fixture.rewardInputs.length, 2, 'retry must skip authority, replay must query it');
+    await assertEntitlementCount(context.store, 1, 'reward retry and replay');
+}
+async function runRewardTimestampValidationScenario(createVerifier, now) {
+    const fixture = createAppsInTossProductionEvidenceAuthorityFixture();
+    fixture.enqueueRewardResult(verifiedReward({
+        authorityEventId: 'ait-authority-event-offset-free',
+        correlationId: 'ait-correlation-offset-free',
+        verifiedAt: '2030-01-02T03:02:00',
+    }));
+    fixture.enqueueRewardResult(verifiedReward({
+        authorityEventId: 'ait-authority-event-offset',
+        correlationId: 'ait-correlation-offset',
+        verifiedAt: '2030-01-02T12:02:00+09:00',
+    }));
+    const context = createScenarioContext(createVerifier, now, {
+        rewardAuthority: fixture.rewardAuthority,
+    });
+    const offsetFree = await context.backend.adRewards.claimAdReward(rewardRequestForCorrelation('ait-correlation-offset-free', {
+        idempotencyKey: 'reward-offset-free',
+    }));
+    const explicitOffset = await context.backend.adRewards.claimAdReward(rewardRequestForCorrelation('ait-correlation-offset', {
+        idempotencyKey: 'reward-explicit-offset',
+    }));
+    assertEqual(offsetFree.reason, 'AIT_REWARD_AUTHORITY_TIMESTAMP_INVALID', 'reward authority timestamps without a zone must fail closed');
+    assertEqual(explicitOffset.granted, true, 'explicit-offset reward timestamp must grant');
+    const [transaction] = await context.store.listEntitlementTransactions();
+    assertEqual(transaction?.payload.evidenceVerifiedAt, '2030-01-02T03:02:00.000Z', 'explicit-offset reward timestamps must normalize without KST fallback');
+    await assertEntitlementCount(context.store, 1, 'reward timestamp validation');
+}
+async function runAuthorityErrorsAndRewardMatchingScenario(createVerifier, now) {
+    const fixture = createAppsInTossProductionEvidenceAuthorityFixture();
+    const diagnosticReason = `Authority temporarily unavailable: ${'x'.repeat(512)} `;
+    const oversizedDiagnosticReason = 'x'.repeat(4097);
+    fixture.enqueuePurchaseResult({ decision: 'rejected', reason: diagnosticReason });
+    fixture.enqueuePurchaseResult({ decision: 'pending', reason: diagnosticReason });
+    fixture.enqueuePurchaseResult({ decision: 'pending', reason: oversizedDiagnosticReason });
+    fixture.enqueueRewardResult(new Error('simulated reward authority failure'));
+    fixture.enqueueRewardResult(verifiedReward({
+        correlationId: 'different-correlation',
+    }));
+    fixture.enqueueRewardResult(verifiedReward({
+        correlationId: 'ait-correlation-player',
+        playerId: 'different-player',
+    }));
+    fixture.enqueueRewardResult(verifiedReward({
+        correlationId: 'ait-correlation-placement',
+        platformPlacementId: 'different-placement',
+    }));
+    fixture.enqueueRewardResult({ decision: 'pending' });
+    fixture.enqueueRewardResult({ decision: 'rejected', reason: diagnosticReason });
+    fixture.enqueueRewardResult({ decision: 'pending', reason: diagnosticReason });
+    fixture.enqueueRewardResult({ decision: 'rejected', reason: oversizedDiagnosticReason });
+    const context = createScenarioContext(createVerifier, now, {
+        purchaseAuthority: fixture.purchaseAuthority,
+        rewardAuthority: fixture.rewardAuthority,
+    });
+    const purchaseRejected = await context.backend.purchases.verifyPurchase(purchaseRequest({ idempotencyKey: 'purchase-free-form-rejected' }));
+    const purchasePending = await context.backend.purchases.verifyPurchase(purchaseRequest({ idempotencyKey: 'purchase-free-form-pending' }));
+    const purchaseOversizedReason = await context.backend.purchases.verifyPurchase(purchaseRequest({ idempotencyKey: 'purchase-oversized-reason' }));
+    const requestCorrelationMismatch = await context.backend.adRewards.claimAdReward(rewardRequest({
+        idempotencyKey: 'reward-request-correlation',
+        platformImpressionId: 'different-request-correlation',
+    }));
+    // Build this request directly so platformImpressionId is absent, not present with undefined.
+    const requestCorrelationMissingRequest = {
+        target: 'ait',
+        playerId: 'ait-player-1',
+        placementId: 'CONFORMANCE_REWARD',
+        idempotencyKey: 'reward-request-correlation-missing',
+        completedAt: '2030-01-02T03:01:00.000Z',
+        evidence: rewardEvidence('ait-correlation-1'),
+    };
+    const requestCorrelationMissing = await context.backend.adRewards.claimAdReward(requestCorrelationMissingRequest);
+    const failed = await context.backend.adRewards.claimAdReward(rewardRequest());
+    const correlationMismatch = await context.backend.adRewards.claimAdReward(rewardRequestForCorrelation('ait-correlation-mismatch', {
+        idempotencyKey: 'reward-correlation',
+    }));
+    const playerMismatch = await context.backend.adRewards.claimAdReward(rewardRequestForCorrelation('ait-correlation-player', {
+        idempotencyKey: 'reward-player',
+    }));
+    const placementMismatch = await context.backend.adRewards.claimAdReward(rewardRequestForCorrelation('ait-correlation-placement', {
+        idempotencyKey: 'reward-placement',
+    }));
+    const pending = await context.backend.adRewards.claimAdReward(rewardRequestForCorrelation('ait-correlation-pending', {
+        idempotencyKey: 'reward-pending',
+    }));
+    const rewardRejected = await context.backend.adRewards.claimAdReward(rewardRequestForCorrelation('ait-correlation-free-form-rejected', {
+        idempotencyKey: 'reward-free-form-rejected',
+    }));
+    const rewardPending = await context.backend.adRewards.claimAdReward(rewardRequestForCorrelation('ait-correlation-free-form-pending', {
+        idempotencyKey: 'reward-free-form-pending',
+    }));
+    const rewardOversizedReason = await context.backend.adRewards.claimAdReward(rewardRequestForCorrelation('ait-correlation-oversized-reason', {
+        idempotencyKey: 'reward-oversized-reason',
+    }));
+    assertEqual(purchaseRejected.reason, diagnosticReason, 'purchase rejection reason forwarding');
+    assertEqual(purchasePending.reason, diagnosticReason, 'purchase pending reason forwarding');
+    assertEqual(purchaseOversizedReason.reason, 'AIT_PURCHASE_AUTHORITY_ERROR', 'oversized purchase authority reason must fail closed');
+    assertEqual(failed.reason, 'AIT_REWARD_AUTHORITY_ERROR', 'reward authority error');
+    assertEqual(requestCorrelationMismatch.reason, 'AIT_REWARD_CORRELATION_ID_MISMATCH', 'reward request correlation mismatch');
+    assertEqual(requestCorrelationMissing.reason, 'AIT_REWARD_REQUEST_CORRELATION_ID_REQUIRED', 'reward request correlation required');
+    assertEqual(correlationMismatch.reason, 'AIT_REWARD_AUTHORITY_CORRELATION_ID_MISMATCH', 'reward correlation mismatch');
+    assertEqual(playerMismatch.reason, 'AIT_REWARD_AUTHORITY_PLAYER_MISMATCH', 'reward player mismatch');
+    assertEqual(placementMismatch.reason, 'AIT_REWARD_AUTHORITY_PLACEMENT_MISMATCH', 'reward placement mismatch');
+    assertEqual(pending.reason, 'AIT_REWARD_AUTHORITY_PENDING', 'reward pending decision');
+    assertEqual(rewardRejected.reason, diagnosticReason, 'reward rejection reason forwarding');
+    assertEqual(rewardPending.reason, diagnosticReason, 'reward pending reason forwarding');
+    assertEqual(rewardOversizedReason.reason, 'AIT_REWARD_AUTHORITY_ERROR', 'oversized reward authority reason must fail closed');
+    assertEqual(fixture.rewardInputs.length, 8, 'request-level correlation failures must not call the reward authority');
+    await assertEntitlementCount(context.store, 0, 'reward errors and mismatches');
+}
+function createScenarioContext(createVerifier, now, authorities = {}, store = createInMemoryGameServicesStore()) {
+    return {
+        backend: createGameServicesBackend({
+            catalog,
+            placements,
+            store,
+            now: () => now,
+            evidenceVerifier: createVerifier(authorities),
+        }),
+        store,
+    };
+}
+function purchaseRequest(overrides = {}) {
+    return {
+        target: 'ait',
+        playerId: 'ait-player-1',
+        productId: 'CONFORMANCE_COINS',
+        platformTransactionId: 'ait-order-1',
+        idempotencyKey: 'purchase-1',
+        purchasedAt: '2030-01-02T03:00:00.000Z',
+        evidence: purchaseEvidence('ait-order-1'),
+        ...overrides,
+    };
+}
+function rewardRequest(overrides = {}) {
+    return {
+        target: 'ait',
+        playerId: 'ait-player-1',
+        placementId: 'CONFORMANCE_REWARD',
+        platformImpressionId: 'ait-correlation-1',
+        idempotencyKey: 'reward-1',
+        completedAt: '2030-01-02T03:01:00.000Z',
+        evidence: rewardEvidence('ait-correlation-1'),
+        ...overrides,
+    };
+}
+function rewardRequestForCorrelation(correlationId, overrides = {}) {
+    return rewardRequest({
+        platformImpressionId: correlationId,
+        evidence: rewardEvidence(correlationId),
+        ...overrides,
+    });
+}
+function purchaseEvidence(orderId) {
+    return createAppsInTossPurchaseCallbackEvidence({
+        orderId,
+        platformSku: 'ait.conformance.coins',
+        source: 'process-product-grant',
+    });
+}
+function rewardEvidence(correlationId) {
+    return createAppsInTossRewardCallbackEvidence({
+        correlationId,
+        platformPlacementId: 'ait.conformance.reward',
+    });
+}
+function resolvedOrder(overrides = {}) {
+    return {
+        decision: 'resolved',
+        order: {
+            orderId: 'ait-order-1',
+            playerId: 'ait-player-1',
+            sku: 'ait.conformance.coins',
+            status: 'PURCHASED',
+            statusDeterminedAt: '2030-01-02T03:02:00+09:00',
+            ...overrides,
+        },
+    };
+}
+function verifiedReward(overrides = {}) {
+    return {
+        decision: 'verified',
+        authorityEventId: 'ait-authority-event-1',
+        correlationId: 'ait-correlation-1',
+        playerId: 'ait-player-1',
+        platformPlacementId: 'ait.conformance.reward',
+        verifiedAt: '2030-01-02T03:02:00.000Z',
+        ...overrides,
+    };
+}
+function createConformanceProductGrantVerificationPort(verifyPurchase) {
+    return createAppsInTossProductGrantVerificationPort(async ({ request, signal }) => {
+        if (signal.aborted) {
+            throw signal.reason;
+        }
+        const response = await verifyPurchase(request, signal);
+        if (signal.aborted) {
+            throw signal.reason;
+        }
+        return response;
+    });
+}
+class AbortAwareConformanceStore extends InMemoryGameServicesStore {
+    grantSignal;
+    async runWithGrantSignal(signal, operation) {
+        if (this.grantSignal !== undefined) {
+            throw new Error('Concurrent conformance grants are not supported.');
+        }
+        this.grantSignal = signal;
+        try {
+            return await operation();
+        }
+        finally {
+            this.grantSignal = undefined;
+        }
+    }
+    async recordEntitlementGrant(input) {
+        if (this.grantSignal === undefined) {
+            throw new Error('Conformance grant signal is required.');
+        }
+        if (this.grantSignal.aborted) {
+            throw this.grantSignal.reason ?? new Error('Conformance grant was aborted.');
+        }
+        return super.recordEntitlementGrant(input);
+    }
+}
+function shiftFixtureResult(queue, exhaustedResult) {
+    const result = queue.shift();
+    if (result === undefined) {
+        return exhaustedResult;
+    }
+    if (result instanceof Error) {
+        throw result;
+    }
+    return result;
+}
+async function assertEntitlementCount(store, expected, label) {
+    assertEqual((await store.listEntitlementTransactions()).length, expected, `${label} ledger count`);
+}
+function createVoidDeferred() {
+    let resolve;
+    const promise = new Promise((promiseResolve) => {
+        resolve = promiseResolve;
+    });
+    return { promise, resolve };
+}
+function assertEqual(actual, expected, label) {
+    if (actual !== expected) {
+        throw new Error(`${label}: expected ${String(expected)}, received ${String(actual)}.`);
+    }
+}