@mpgd/game-services 0.22.0 → 0.24.0

package/dist/monetization-recovery.js

@@ -1,8 +1,8 @@
-import { isAuthoritativeMicrosoftStoreCompletion } from './authoritative-purchase.js';
 import { createGameServicesClient, } from './client.js';
 import { resolveClientRewardClaim } from './client-reward-evidence.js';
-import { summarizeCommercePurchaseOperation, toGameServicesPurchaseResult, } from './commerce-reconciler.js';
+import { summarizeCommercePurchaseOperation, } from './commerce-reconciler.js';
 import { createDefaultClientRewardEvidenceRegistry } from './default-client-reward-evidence.js';
+import { isRetiredPurchaseOpen } from './monetization-operation-store.js';
 import { forwardGameServicesProgress, observeGameServicesOperation, } from './operation-progress.js';
 /**
  * Client-side recovery coordinates UI callbacks and authoritative backend calls.
@@ -15,24 +15,22 @@ export function createRecoverableMonetizationClient(input) {
     const allowLegacyRewardCompletion = input.rewardEvidenceRegistry === undefined && input.gateway.ads.provider === undefined;
     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();
-    // One commerce v2 client over the durable journal: its reconciler is the
-    // purchase path for a gateway with a v2 provider, and v1 records keep the
-    // per-operation client below.
-    const commerceClient = input.gateway.commerceV2 === undefined
-        ? undefined
-        : createGameServicesClient({ ...input, operationStore: store });
-    const commerceReconciler = commerceClient?.commerceReconciler;
-    // The per-operation clients below resume v1 records only: they see a gateway
-    // without the v2 provider, so they never build a second reconciler over the
-    // journal or reopen the store UI for a platform result already recorded.
+    // One purchase client over the durable journal: its reconciler is the only
+    // purchase path. A gateway without a commerce provider gets a client whose
+    // `purchase` answers `rejected`; rewarded ads keep the per-operation client
+    // below.
+    const commerceClient = createGameServicesClient({
+        ...input,
+        operationStore: store,
+    });
+    const commerceReconciler = commerceClient.commerceReconciler;
+    // The per-operation rewarded-ad clients see a gateway without the commerce
+    // provider, so they never build a second reconciler over the journal.
     const { commerceReconciler: _sharedReconciler, operationStore: _journal, onCommerceEvent: _onCommerceEvent, commerceProducts: _commerceProducts, ...legacyClientInput } = input;
-    const { commerceV2: _commerceV2, ...legacyGateway } = input.gateway;
+    const { commerce: _commerce, ...legacyGateway } = input.gateway;
     async function serializeOperation(key, task) {
         const previous = inFlight.get(key) ?? Promise.resolve();
         const running = previous.catch(() => undefined).then(task);
@@ -57,35 +55,12 @@ export function createRecoverableMonetizationClient(input) {
             || record.target !== input.target
             || record.deploymentTarget !== (input.deploymentTarget ?? input.target)
             || record.input.idempotencyKey !== idempotencyKey
-            || (record.kind === 'purchase' ? record.input.productId : record.input.placementId)
-                !== subjectId) {
+            || record.input.placementId !== subjectId) {
             throw new Error('Monetization operation key is bound to another player or subject.');
         }
     }
-    async function purchase(operation, options) {
-        if (commerceClient !== undefined) {
-            return commerceClient.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);
-        });
+    function purchase(operation, options) {
+        return commerceClient.purchase(operation, options);
     }
     async function claimRewardedAd(operation, options) {
         const key = operationKey(input.target, 'rewarded-ad', operation.idempotencyKey);
@@ -106,163 +81,6 @@ export function createRecoverableMonetizationClient(input) {
             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({
-            ...legacyClientInput,
-            requestNow: () => record.platformCompletedAt ?? observedAt(),
-            gateway: {
-                ...legacyGateway,
-                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);
@@ -417,50 +235,6 @@ export function createRecoverableMonetizationClient(input) {
                 ?? 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') {
-                if (commerceReconciler !== undefined) {
-                    // Deprecated thin wrapper: the v2 reconciler learns the result from
-                    // the provider, so the platform callback is not replayed.
-                    await commerceReconciler.reconcile();
-                    const journaled = await commerceReconciler.read(idempotencyKey);
-                    if (journaled === undefined) {
-                        throw new Error('No reserved purchase operation matches this platform callback.');
-                    }
-                    return toGameServicesPurchaseResult(journaled);
-                }
-                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 () => {
@@ -585,6 +359,104 @@ export function createRecoverableMonetizationClient(input) {
             })),
         ];
     }
+    /**
+     * Finishes the backend verification a retired v1 purchase record was in the
+     * middle of. The grant is the backend's answer, never a local decision, and
+     * the store UI is never reopened. Backend or journal trouble leaves the
+     * record open for the next pass.
+     */
+    async function drainRetiredPurchase(initial) {
+        const summarize = (latest, status, finalizationPending = false) => ({
+            kind: 'purchase',
+            idempotencyKey: latest.input.idempotencyKey,
+            status,
+            finalizationPending,
+        });
+        try {
+            return await serializeOperation(initial.key, async () => {
+                const latest = await store.read(initial.key) ?? initial;
+                if (latest.kind !== 'purchase' || !isRetiredPurchaseOpen(latest)) {
+                    return undefined;
+                }
+                if (latest.key !== operationKey(input.target, 'purchase', latest.input.idempotencyKey)
+                    || !ownsRecord(latest)) {
+                    return summarize(latest, 'action-required');
+                }
+                const platform = latest.platform;
+                if (platform?.status !== 'completed' || platform.transactionId === undefined) {
+                    return undefined;
+                }
+                const request = latest.request ?? {
+                    target: latest.target,
+                    ...(latest.deploymentTarget === latest.target
+                        ? {}
+                        : { deploymentTarget: latest.deploymentTarget }),
+                    playerId: latest.playerId,
+                    productId: latest.input.productId,
+                    platformTransactionId: platform.transactionId,
+                    idempotencyKey: latest.input.idempotencyKey,
+                    purchasedAt: latest.platformCompletedAt ?? observedAt(),
+                    ...(platform.evidence === undefined ? {} : { evidence: platform.evidence }),
+                };
+                if (request.playerId !== input.playerId
+                    || request.target !== latest.target
+                    || (request.deploymentTarget ?? request.target) !== latest.deploymentTarget
+                    || request.productId !== latest.input.productId
+                    || request.idempotencyKey !== latest.input.idempotencyKey
+                    || request.platformTransactionId !== platform.transactionId) {
+                    return summarize(latest, 'action-required');
+                }
+                // A grant whose consume or acknowledge is still pending is sent once
+                // more as well: the backend retries the finalization of a ledger
+                // entry it already holds under the same key, as the v1 client did.
+                const saved = latest.response;
+                let response = saved;
+                if (saved?.verified !== true || saved.finalization?.status === 'pending') {
+                    let answer;
+                    try {
+                        answer = await input.backend.purchases.verifyPurchase(request);
+                    }
+                    catch {
+                        // Transport trouble stays retryable; nothing is decided here.
+                        return saved?.verified === true
+                            ? summarize(latest, 'granted', true)
+                            : summarize(latest, 'pending');
+                    }
+                    // A recorded grant is never replaced by a later non-grant answer.
+                    response = saved?.verified === true && !answer.verified ? saved : answer;
+                }
+                if (response === undefined) {
+                    return summarize(latest, 'pending');
+                }
+                const finalizationPending = response.verified
+                    && response.finalization?.status === 'pending';
+                const result = response.verified
+                    ? {
+                        status: 'granted',
+                        purchase: platform,
+                        verification: response,
+                        ...(response.ledgerEntryId === undefined
+                            ? {}
+                            : { ledgerEntryId: response.ledgerEntryId }),
+                    }
+                    : {
+                        status: response.disposition === 'pending' ? 'pending' : 'rejected',
+                        purchase: platform,
+                        verification: response,
+                    };
+                try {
+                    await save(latest, { request, response, result });
+                }
+                catch {
+                    return summarize(latest, result.status === 'granted' ? 'granted' : 'pending', finalizationPending);
+                }
+                return summarize(latest, result.status === 'granted' ? 'granted' : result.status, finalizationPending);
+            });
+        }
+        catch {
+            return summarize(initial, 'pending');
+        }
+    }
     async function reconcileLegacy() {
         const pending = await store.listRecoverable(input.playerId);
         const summaries = [];
@@ -592,7 +464,14 @@ export function createRecoverableMonetizationClient(input) {
             if (!ownsRecord(record)) {
                 continue;
             }
-            if (record.kind !== 'purchase' && record.kind !== 'rewarded-ad') {
+            if (record.kind === 'purchase') {
+                const summary = await drainRetiredPurchase(record);
+                if (summary !== undefined) {
+                    summaries.push(summary);
+                }
+                continue;
+            }
+            if (record.kind !== 'rewarded-ad') {
                 continue;
             }
             const idempotencyKey = typeof record.input?.idempotencyKey === 'string'
@@ -610,19 +489,10 @@ export function createRecoverableMonetizationClient(input) {
                     catch {
                         throw new OperationReadError();
                     }
-                    if (latest.kind === 'commerce-purchase') {
+                    if (latest.kind !== 'rewarded-ad') {
                         throw new Error('Monetization operation kind conflicts with its journal key.');
                     }
-                    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',
-                        };
-                    }
+                    assertOwner(latest, latest.kind, latest.input.idempotencyKey, latest.input.placementId);
                     const result = await resumeReward(latest);
                     return {
                         kind: latest.kind,
@@ -647,7 +517,6 @@ export function createRecoverableMonetizationClient(input) {
     return {
         purchase,
         claimRewardedAd,
-        recoverPurchaseResult,
         recoverRewardResult,
         reconcile,
         restorePurchases,
@@ -678,42 +547,12 @@ function canonicalJson(value) {
     }
     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;
@@ -729,22 +568,6 @@ function recordedRewardGrant(record) {
             ? {} : { 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;
     const candidate = record.platform === undefined ? undefined : resolveClientRewardClaim(record.platform, input.rewardEvidenceRegistry ?? createDefaultClientRewardEvidenceRegistry(), { allowLegacyCompletion: input.rewardEvidenceRegistry === undefined && input.gateway.ads.provider === undefined });

package/dist/notification-delivery.d.ts

@@ -26,7 +26,15 @@ export declare class NotificationDeliveryNotSentError extends Error {
   readonly name = "NotificationDeliveryNotSentError";
 }
 export interface NotificationDeepLinkPolicy {
-  /** Exact HTTP(S) origins permitted for absolute links. Root-relative links are always allowed. */
+  /**
+  * Exact HTTP(S) origins permitted for absolute links. Root-relative links are
+  * allowed when they stay a path on the game origin, so one that names a host
+  * after a backslash (`/\host`) is rejected. Either kind is rejected when its
+  * path would begin with an empty segment after dot segments collapse
+  * (`/.//host`), or after it is percent-decoded once and parsed again
+  * (`/%2F/host`, `/%5Chost`, `/%09/host`, `/.%2F/host`), or when it is longer
+  * than 2,048 characters after normalization.
+  */
   readonly allowedOrigins?: readonly string[];
 }
 export interface NotificationDeliveryClaimOptions extends NotificationDeepLinkPolicy {

package/dist/notification-delivery.js

@@ -1,3 +1,4 @@
+import { hasNetworkPathPrefix, normalizeRootRelativeRoute } from '@mpgd/platform/routes';
 import { assertOwnEnumerablePropertyLimit } from './validation.js';
 const platformTargets = new Set([
     'browser',
@@ -20,6 +21,8 @@ const notificationTopics = new Set([
 const defaultClaimLeaseMs = 5 * 60 * 1_000;
 const maxCompletionAttempts = 3;
 const maxNotificationTemplateDataEntries = 128;
+/** Caps identifiers, including a deep link after normalization so it normalizes to itself. */
+const maxIdentifierLength = 2_048;
 /** Throw only when the provider can prove that no external send was attempted. */
 export class NotificationDeliveryNotSentError extends Error {
     name = 'NotificationDeliveryNotSentError';
@@ -331,17 +334,14 @@ function normalizeTemplateData(input) {
     return Object.fromEntries(entries);
 }
 function normalizeDeepLink(input, allowedOrigins) {
+    // normalizeIdentifier already refused control characters.
     const deepLink = normalizeIdentifier(input, 'deepLink');
-    if (/[\x00-\x1F\x7F]/u.test(deepLink)) {
-        throw new Error('deepLink must not contain control characters.');
-    }
     if (deepLink.startsWith('/') && !deepLink.startsWith('//')) {
-        const baseUrl = new URL('https://mpgd.invalid');
-        const parsed = new URL(deepLink, baseUrl);
-        if (parsed.origin !== baseUrl.origin) {
+        const route = normalizeRootRelativeRoute(deepLink);
+        if (route === undefined) {
             throw new Error('deepLink must stay on the configured game origin.');
         }
-        return `${parsed.pathname}${parsed.search}${parsed.hash}`;
+        return requireNormalizedDeepLinkLength(route);
     }
     let parsed;
     try {
@@ -359,7 +359,17 @@ function normalizeDeepLink(input, allowedOrigins) {
     if (!allowedOrigins.has(parsed.origin)) {
         throw new Error('deepLink origin is not allowed.');
     }
-    return parsed.toString();
+    if (hasNetworkPathPrefix(parsed.pathname)) {
+        throw new Error('deepLink path must not begin with an empty segment, even after percent-decoding.');
+    }
+    return requireNormalizedDeepLinkLength(parsed.toString());
+}
+/** Normalization can grow a link; keep it within the input cap so it normalizes to itself. */
+function requireNormalizedDeepLinkLength(deepLink) {
+    if (deepLink.length > maxIdentifierLength) {
+        throw new Error(`deepLink must contain at most ${String(maxIdentifierLength)} characters after normalization.`);
+    }
+    return deepLink;
 }
 function normalizeAllowedDeepLinkOrigins(input) {
     const origins = new Set();
@@ -427,7 +437,7 @@ function assertRecord(input, label) {
 function normalizeIdentifier(input, label) {
     if (typeof input !== 'string'
         || input.length === 0
-        || input.length > 2_048
+        || input.length > maxIdentifierLength
         || input.trim() !== input) {
         throw new Error(`${label} must be a non-empty, trimmed string.`);
     }

package/dist/runtime.d.ts

@@ -3,6 +3,7 @@ import type { PlatformGateway, PlatformTarget } from '@mpgd/platform';
 import { type GameServicesBackendApi, type GameServicesBackendTransport, type GameServicesClient, type GameServicesHeaderResolver } from './client.js';
 import type { GameServicesLedgerTarget } from './types.js';
 import type { ClientRewardEvidenceRegistry } from './client-reward-evidence.js';
+import type { CommerceReconcilerProduct } from './commerce-reconciler.js';
 import { type MonetizationOperationStore, type RecoverableMonetizationClient } from './monetization-recovery.js';
 export type GameServicesAuthorityMode = 'production' | 'non-production';
 export type GameServicesRuntimeMode = 'disabled' | 'local' | 'http' | 'orpc';
@@ -34,6 +35,12 @@ interface CreateGameServicesRuntimeCommonInput {
   /** Durable, compare-and-swap journal for purchase and rewarded-ad recovery. */
   readonly operationStore?: MonetizationOperationStore;
   readonly rewardEvidenceRegistry?: ClientRewardEvidenceRegistry;
+  /**
+  * Catalog kinds and store SKUs the commerce v2 reconciler resolves without a
+  * store read (`CommerceReconcilerProduct`), for example derived from the
+  * product catalog's `platformProductIds` for the gateway target.
+  */
+  readonly commerceProducts?: readonly CommerceReconcilerProduct[];
 }
 export type CreateGameServicesRuntimeInput = CreateGameServicesRuntimeCommonInput & ({
   readonly transport?: 'http';

package/dist/runtime.js

@@ -62,6 +62,7 @@ export function createGameServicesRuntime(input) {
             : { analyticsSessionId: input.analyticsSessionId }),
         ...(input.now === undefined ? {} : { now: input.now }),
         ...(input.rewardEvidenceRegistry === undefined ? {} : { rewardEvidenceRegistry: input.rewardEvidenceRegistry }),
+        ...(input.commerceProducts === undefined ? {} : { commerceProducts: input.commerceProducts }),
     };
     const monetizationRecovery = input.operationStore === undefined
         ? undefined

package/dist/types.d.ts

@@ -5,15 +5,6 @@ import type { ClaimAdRewardResponse, PurchaseGrantFinalization, PurchaseLedgerSt
 export type { ClaimAdRewardResponse, PurchaseGrantFinalization, PurchaseGrantFinalizationAction, PurchaseLedgerStatus, PurchaseLedgerStatusRequest, PurchaseLedgerStatusResponse, VerifyPurchaseResponse, } from './operation-results.js';
 export type { PlatformEvidenceEnvelope } from '@mpgd/platform';
 /**
-* The closed v1 purchase target list. The deployment target of a v1 verify
-* request names its store implicitly (`android` is Google Play, `ios` the App
-* Store, `ait` Apps in Toss); `resolveLegacyCommerceStoreId` is that mapping.
-*
-* @deprecated `VerifyPurchaseRequest.target` is open since commerce v2 C2
-* (`GameServicesStoreTarget` is `StoreId`); C4 removes this alias.
-*/
-export type GameServicesLegacyStoreTarget = Extract<PlatformTarget, 'microsoft-store' | 'android' | 'ios' | 'ait' | 'oneplay'>;
-/**
 * An open store or deployment target identifier (RFC "Open store ids"). The
 * request validator bounds its shape; the backend's commerce evidence
 * registry decides which stores it serves.