@mpgd/game-services 0.10.0 → 0.11.1

package/dist/apps-in-toss-partner-api.d.ts

@@ -0,0 +1,48 @@
+import type { NotificationTemplateData } from './notification-delivery';
+export declare const appsInTossPartnerApiBaseUrl = "https://apps-in-toss-api.toss.im";
+export declare const defaultAppsInTossPartnerApiTimeoutMs = 10000;
+/** Compatible with a Cloudflare mTLS certificate binding (`env.BINDING.fetch`). */
+export interface AppsInTossMutualTlsFetcher {
+  fetch(input: string, init?: RequestInit): Promise<Response>;
+}
+export type AppsInTossMessageRecipient = {
+  readonly type: 'anonymous';
+  readonly key: string;
+} | {
+  readonly type: 'toss-user';
+  readonly key: string;
+};
+export interface SendAppsInTossFunctionalMessageInput {
+  readonly recipient: AppsInTossMessageRecipient;
+  readonly templateSetCode: string;
+  readonly context: NotificationTemplateData;
+  readonly signal?: AbortSignal;
+}
+export interface AppsInTossFunctionalMessageResult {
+  readonly messageCount: number;
+  readonly sentPushCount: number;
+  readonly sentInboxCount: number;
+  readonly sentSmsCount: number;
+  readonly sentAlimtalkCount: number;
+  readonly sentFriendtalkCount: number;
+  readonly contentIds: readonly string[];
+}
+export interface AppsInTossPartnerApiClient {
+  verifyAnonymousKey(input: {
+    readonly anonymousKey: string;
+    readonly signal?: AbortSignal;
+  }): Promise<boolean>;
+  sendFunctionalMessage(input: SendAppsInTossFunctionalMessageInput): Promise<AppsInTossFunctionalMessageResult>;
+}
+export interface CreateAppsInTossPartnerApiClientInput {
+  readonly mtls: AppsInTossMutualTlsFetcher;
+  readonly baseUrl?: string;
+  readonly timeoutMs?: number;
+}
+export declare class AppsInTossPartnerApiError extends Error {
+  readonly status: number;
+  readonly code?: string | undefined;
+  readonly name = "AppsInTossPartnerApiError";
+  constructor(message: string, status: number, code?: string | undefined, options?: ErrorOptions);
+}
+export declare function createAppsInTossPartnerApiClient(input: CreateAppsInTossPartnerApiClientInput): AppsInTossPartnerApiClient;

package/dist/apps-in-toss-partner-api.js

@@ -0,0 +1,282 @@
+export const appsInTossPartnerApiBaseUrl = 'https://apps-in-toss-api.toss.im';
+export const defaultAppsInTossPartnerApiTimeoutMs = 10000;
+const verifyAnonymousKeyPath = 'api-partner/v1/apps-in-toss/users/anon-key/verify';
+const sendFunctionalMessagePath = 'api-partner/v1/apps-in-toss/messenger/send-message';
+const maximumResponseBodyBytes = 256 * 1024;
+export class AppsInTossPartnerApiError extends Error {
+    status;
+    code;
+    name = 'AppsInTossPartnerApiError';
+    constructor(message, status, code, options) {
+        super(message, options);
+        this.status = status;
+        this.code = code;
+    }
+}
+export function createAppsInTossPartnerApiClient(input) {
+    const baseUrl = normalizeBaseUrl(input.baseUrl ?? appsInTossPartnerApiBaseUrl);
+    const timeoutMs = normalizeTimeout(input.timeoutMs);
+    return {
+        async verifyAnonymousKey(request) {
+            const anonymousKey = normalizeIdentifier(request.anonymousKey, 'anonymousKey');
+            const response = await postJson({
+                mtls: input.mtls,
+                url: new URL(verifyAnonymousKeyPath, baseUrl).href,
+                headers: { 'x-anon-key': anonymousKey },
+                body: undefined,
+                timeoutMs,
+                ...(request.signal === undefined ? {} : { signal: request.signal }),
+            });
+            if (response.status === 401) {
+                return false;
+            }
+            const envelope = requireSuccessEnvelope(response);
+            if (envelope.success !== 'true') {
+                throw new AppsInTossPartnerApiError('Apps in Toss returned an invalid anonymous-key verification response.', response.status);
+            }
+            return true;
+        },
+        async sendFunctionalMessage(request) {
+            const recipient = normalizeRecipient(request.recipient);
+            const templateSetCode = normalizeIdentifier(request.templateSetCode, 'templateSetCode');
+            const response = await postJson({
+                mtls: input.mtls,
+                url: new URL(sendFunctionalMessagePath, baseUrl).href,
+                headers: recipient.type === 'anonymous'
+                    ? { 'x-anon-key': recipient.key }
+                    : { 'x-toss-user-key': recipient.key },
+                body: {
+                    templateSetCode,
+                    context: normalizeContext(request.context),
+                },
+                timeoutMs,
+                ...(request.signal === undefined ? {} : { signal: request.signal }),
+            });
+            const envelope = requireSuccessEnvelope(response);
+            return parseFunctionalMessageResult(envelope.success, response.status);
+        },
+    };
+}
+async function postJson(input) {
+    const timeout = createTimeoutSignal(input.signal, input.timeoutMs);
+    try {
+        // The documented anonymous-key verification request uses an empty body
+        // while still declaring application/json.
+        const requestBody = input.body === undefined ? '' : JSON.stringify(input.body);
+        const headers = new Headers({
+            accept: 'application/json',
+            'content-type': 'application/json',
+            ...input.headers,
+        });
+        let response;
+        let text;
+        try {
+            response = await input.mtls.fetch(input.url, {
+                method: 'POST',
+                headers,
+                body: requestBody,
+                signal: timeout.signal,
+            });
+            text = await readBoundedResponseText(response);
+        }
+        catch (error) {
+            throw normalizeTransportError(error, input.signal, timeout.signal);
+        }
+        let body;
+        try {
+            body = text.length === 0 ? undefined : JSON.parse(text);
+        }
+        catch {
+            throw new AppsInTossPartnerApiError('Apps in Toss returned a non-JSON response.', response.status);
+        }
+        return { status: response.status, ok: response.ok, body };
+    }
+    finally {
+        timeout.cleanup();
+    }
+}
+function normalizeTransportError(error, upstream, effective) {
+    if (error instanceof AppsInTossPartnerApiError) {
+        return error;
+    }
+    if (effective.aborted && upstream?.aborted !== true) {
+        return new AppsInTossPartnerApiError('Apps in Toss partner API request timed out.', 0, 'TIMEOUT', { cause: error });
+    }
+    if (upstream?.aborted === true) {
+        return new AppsInTossPartnerApiError('Apps in Toss partner API request was aborted.', 0, 'ABORTED', { cause: error });
+    }
+    return new AppsInTossPartnerApiError('Apps in Toss partner API transport failed.', 0, 'TRANSPORT_ERROR', { cause: error });
+}
+async function readBoundedResponseText(response) {
+    const declaredLength = response.headers.get('content-length');
+    if (declaredLength !== null
+        && /^\d+$/u.test(declaredLength)
+        && Number(declaredLength) > maximumResponseBodyBytes) {
+        throw responseTooLarge(response.status);
+    }
+    if (response.body === null) {
+        return '';
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let byteLength = 0;
+    try {
+        while (true) {
+            const chunk = await reader.read();
+            if (chunk.done) {
+                break;
+            }
+            byteLength += chunk.value.byteLength;
+            if (byteLength > maximumResponseBodyBytes) {
+                await reader.cancel().catch(() => { });
+                throw responseTooLarge(response.status);
+            }
+            chunks.push(chunk.value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    const bytes = new Uint8Array(byteLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    try {
+        return new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+    }
+    catch {
+        throw new AppsInTossPartnerApiError('Apps in Toss returned a non-UTF-8 response.', response.status);
+    }
+}
+function responseTooLarge(status) {
+    return new AppsInTossPartnerApiError('Apps in Toss response exceeded the maximum accepted size.', status);
+}
+function requireSuccessEnvelope(response) {
+    if (!isRecord(response.body)) {
+        throw new AppsInTossPartnerApiError('Apps in Toss returned an invalid response envelope.', response.status);
+    }
+    if (response.ok && response.body.resultType === 'SUCCESS') {
+        return response.body;
+    }
+    const error = isRecord(response.body.error) ? response.body.error : undefined;
+    const code = typeof error?.errorCode === 'string' ? error.errorCode : undefined;
+    const reason = typeof error?.reason === 'string'
+        ? error.reason.slice(0, 1024)
+        : 'Apps in Toss partner API request failed.';
+    throw new AppsInTossPartnerApiError(reason, response.status, code);
+}
+function parseFunctionalMessageResult(input, status) {
+    if (!isRecord(input)) {
+        throw new AppsInTossPartnerApiError('Apps in Toss returned an invalid message result.', status);
+    }
+    return {
+        messageCount: requireCount(input.msgCount, 'msgCount', status),
+        sentPushCount: requireCount(input.sentPushCount, 'sentPushCount', status),
+        sentInboxCount: requireCount(input.sentInboxCount, 'sentInboxCount', status),
+        sentSmsCount: requireCount(input.sentSmsCount, 'sentSmsCount', status),
+        sentAlimtalkCount: requireCount(input.sentAlimtalkCount, 'sentAlimtalkCount', status),
+        sentFriendtalkCount: requireCount(input.sentFriendtalkCount, 'sentFriendtalkCount', status),
+        contentIds: readContentIds(input.detail),
+    };
+}
+function readContentIds(detail) {
+    if (!isRecord(detail)) {
+        return [];
+    }
+    const ids = new Set();
+    for (const channel of ['sentPush', 'sentInbox', 'sentSms', 'sentAlimtalk', 'sentFriendtalk']) {
+        const entries = detail[channel];
+        if (!Array.isArray(entries)) {
+            continue;
+        }
+        for (const entry of entries) {
+            if (isRecord(entry) && typeof entry.contentId === 'string' && entry.contentId.length > 0) {
+                ids.add(entry.contentId);
+            }
+        }
+    }
+    return [...ids];
+}
+function requireCount(value, field, status) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new AppsInTossPartnerApiError(`Apps in Toss returned an invalid ${field}.`, status);
+    }
+    return value;
+}
+function normalizeRecipient(input) {
+    if (input.type !== 'anonymous' && input.type !== 'toss-user') {
+        throw new TypeError('AIT message recipient type is invalid.');
+    }
+    return { type: input.type, key: normalizeIdentifier(input.key, 'recipient.key') };
+}
+function normalizeContext(input) {
+    const entries = Object.entries(input);
+    if (entries.length > 128) {
+        throw new TypeError('AIT message context cannot contain more than 128 values.');
+    }
+    const output = Object.create(null);
+    for (const [key, value] of entries) {
+        const normalizedKey = normalizeIdentifier(key, 'context key');
+        if (typeof value !== 'string'
+            && typeof value !== 'number'
+            && typeof value !== 'boolean') {
+            throw new TypeError(`AIT message context value is invalid: ${normalizedKey}`);
+        }
+        if (typeof value === 'number' && !Number.isFinite(value)) {
+            throw new TypeError(`AIT message context number is invalid: ${normalizedKey}`);
+        }
+        output[normalizedKey] = value;
+    }
+    return output;
+}
+function normalizeIdentifier(value, field) {
+    const normalized = value.trim();
+    if (normalized.length === 0
+        || normalized.length > 2048
+        || /[\p{Cc}\p{Cf}]/u.test(normalized)) {
+        throw new TypeError(`${field} must contain 1 to 2048 characters without control or format characters.`);
+    }
+    return normalized;
+}
+function normalizeBaseUrl(input) {
+    const url = new URL(input);
+    if (url.protocol !== 'https:'
+        || url.username.length > 0
+        || url.password.length > 0
+        || url.search.length > 0
+        || url.hash.length > 0) {
+        throw new TypeError('AIT partner API baseUrl must be a credential-free HTTPS URL.');
+    }
+    url.pathname = url.pathname.endsWith('/') ? url.pathname : `${url.pathname}/`;
+    return url;
+}
+function normalizeTimeout(value) {
+    const timeoutMs = value ?? defaultAppsInTossPartnerApiTimeoutMs;
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0 || timeoutMs > 60000) {
+        throw new TypeError('AIT partner API timeoutMs must be between 1 and 60000.');
+    }
+    return timeoutMs;
+}
+function createTimeoutSignal(upstream, timeoutMs) {
+    const controller = new AbortController();
+    const abortFromUpstream = () => controller.abort(upstream?.reason);
+    if (upstream?.aborted === true) {
+        abortFromUpstream();
+    }
+    else {
+        upstream?.addEventListener('abort', abortFromUpstream, { once: true });
+    }
+    const timer = globalThis.setTimeout(() => controller.abort(new Error('Apps in Toss partner API request timed out.')), timeoutMs);
+    return {
+        signal: controller.signal,
+        cleanup() {
+            globalThis.clearTimeout(timer);
+            upstream?.removeEventListener('abort', abortFromUpstream);
+        },
+    };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/client.d.ts

@@ -74,6 +74,7 @@ export interface CreateGameServicesClientInput {
   readonly backend: GameServicesBackendApi;
   readonly playerId: string;
   readonly target: GameServicesLedgerTarget;
+  readonly deploymentTarget?: string;
   readonly analytics?: AnalyticsSink;
   readonly analyticsSessionId?: string;
   readonly now?: () => string;

package/dist/client.js

@@ -83,6 +83,9 @@ export function createGameServicesClient(input) {
             }
             const verification = await input.backend.purchases.verifyPurchase({
                 target,
+                ...(input.deploymentTarget === undefined || input.deploymentTarget === target
+                    ? {}
+                    : { deploymentTarget: input.deploymentTarget }),
                 playerId: input.playerId,
                 productId: purchaseInput.productId,
                 platformTransactionId: purchase.transactionId,
@@ -148,6 +151,9 @@ export function createGameServicesClient(input) {
             }
             const claim = await input.backend.adRewards.claimAdReward({
                 target,
+                ...(input.deploymentTarget === undefined || input.deploymentTarget === target
+                    ? {}
+                    : { deploymentTarget: input.deploymentTarget }),
                 playerId: input.playerId,
                 placementId: rewardInput.placementId,
                 ...(reward.ledgerEntryId === undefined

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from './admob-ssv.js';
 export * from './app-store-verifier';
 export * from './apps-in-toss-evidence-verification';
+export * from './apps-in-toss-partner-api';
 export * from './client';
 export * from './contract';
 export * from './evidence-verification';

package/dist/index.js

@@ -1,6 +1,7 @@
 export * from './admob-ssv.js';
 export * from './app-store-verifier';
 export * from './apps-in-toss-evidence-verification';
+export * from './apps-in-toss-partner-api';
 export * from './client';
 export * from './contract';
 export * from './evidence-verification';

package/dist/runtime.d.ts

@@ -17,6 +17,7 @@ export interface CreateGameServicesRuntimeInput {
   readonly playerId: string;
   readonly authorityMode: GameServicesAuthorityMode;
   readonly target?: PlatformTarget | string;
+  readonly deploymentTarget?: string;
   readonly baseUrl?: string;
   readonly transport?: 'http' | 'orpc';
   readonly allowLocalBackend?: boolean;

package/dist/runtime.js

@@ -46,6 +46,9 @@ export function createGameServicesRuntime(input) {
             backend,
             playerId: input.playerId,
             target,
+            ...(input.deploymentTarget === undefined
+                ? {}
+                : { deploymentTarget: input.deploymentTarget }),
             ...(input.analytics === undefined ? {} : { analytics: input.analytics }),
             ...(input.analyticsSessionId === undefined
                 ? {}

package/dist/server.d.ts

@@ -1,13 +1,15 @@
 import { type AnalyticsSink } from '@mpgd/analytics';
-import type { AdPlacements, ProductCatalog } from '@mpgd/catalog';
+import { type AdPlacements, type ProductCatalog } from '@mpgd/catalog';
 import { type GameServicesBackendApi, type GameServicesBackendTransport, type GameServicesBackendTransportRequest, type GameServicesBackendTransportResponse } from './client';
 import { type GameServicesHealthResponse } from './contract';
 import { type GameServicesEvidenceVerifier, type GameServicesPurchaseGrantFinalizer } from './evidence-verification';
-import { type ClaimAdRewardRequest, type ClaimAdRewardResponse, type EntitlementLedgerGrant, type EntitlementLedgerResult, type LeaderboardScoreTransaction, type ProductGrantTransaction, type RecordLeaderboardScoreRequest, type RecordLeaderboardScoreResponse, type VerifyPurchaseRequest, type VerifyPurchaseResponse } from './types';
+import { type ClaimAdRewardRequest, type ClaimAdRewardResponse, type EntitlementLedgerGrant, type EntitlementLedgerResult, type GameServicesAdRewardTarget, type LeaderboardScoreTransaction, type ProductGrantTransaction, type RecordLeaderboardScoreRequest, type RecordLeaderboardScoreResponse, type VerifyPurchaseRequest, type VerifyPurchaseResponse } from './types';
 type CorsHeaders = Record<string, string>;
 export interface CreateGameServicesBackendInput {
   readonly catalog: ProductCatalog;
   readonly placements: AdPlacements;
+  /** Trusted deployment-config bindings keyed by the request's platform target. */
+  readonly deploymentTargetBindings?: GameServicesDeploymentTargetBindings;
   readonly store?: GameServicesStore;
   readonly analytics?: AnalyticsSink;
   readonly analyticsSessionId?: string;
@@ -18,6 +20,7 @@ export interface CreateGameServicesBackendInput {
   readonly purchaseGrantFinalizationTimeoutMs?: number;
   readonly purchaseGrantFinalizer?: GameServicesPurchaseGrantFinalizer;
 }
+export type GameServicesDeploymentTargetBindings = Readonly<Partial<Record<GameServicesAdRewardTarget, string>>>;
 export interface GameServicesBackendApiHandler {
   readonly version?: string;
   handle(request: GameServicesBackendTransportRequest): Promise<GameServicesBackendTransportResponse>;

package/dist/server.js

@@ -1,10 +1,11 @@
 import { implement } from '@orpc/server';
 import { RPCHandler } from '@orpc/server/fetch';
 import { createAnalyticsReporter } from '@mpgd/analytics';
+import { resolveAdPlacementPlatformId, resolveProductPlatformId, } from '@mpgd/catalog';
 import { gameServicesBackendEndpoints, } from './client';
 import { gameServicesContract } from './contract';
 import { createRejectingGameServicesEvidenceVerifier, } from './evidence-verification';
-import { assertClaimAdRewardRequest, assertClaimAdRewardResponse, assertEntitlementLedgerGrant, assertEntitlementLedgerResult, assertLeaderboardScoreTransaction, assertProductGrantTransaction, assertPurchaseGrantFinalization, assertRecordLeaderboardScoreRequest, assertRecordLeaderboardScoreResponse, assertVerifyPurchaseRequest, assertVerifyPurchaseResponse, } from './types';
+import { assertClaimAdRewardRequest, assertClaimAdRewardResponse, assertEntitlementLedgerGrant, assertEntitlementLedgerResult, assertGameServicesDeploymentTarget, assertLeaderboardScoreTransaction, assertProductGrantTransaction, assertPurchaseGrantFinalization, assertRecordLeaderboardScoreRequest, assertRecordLeaderboardScoreResponse, assertVerifyPurchaseRequest, assertVerifyPurchaseResponse, } from './types';
 export class InMemoryGameServicesStore {
     entitlementTransactionsByKey = new Map();
     entitlementTransactionsByEvidence = new Map();
@@ -130,6 +131,7 @@ export function createGameServicesBackend(input) {
     const evidenceVerifier = input.evidenceVerifier ?? createRejectingGameServicesEvidenceVerifier();
     const evidenceVerificationTimeoutMs = resolveEvidenceVerificationTimeout(input.evidenceVerificationTimeoutMs);
     const purchaseGrantFinalizationTimeoutMs = resolvePurchaseGrantFinalizationTimeout(input.purchaseGrantFinalizationTimeoutMs);
+    const deploymentTargetBindings = resolveDeploymentTargetBindings(input.deploymentTargetBindings);
     const analytics = createAnalyticsReporter({
         target: 'server',
         sessionId: input.analyticsSessionId ?? 'game-services',
@@ -147,6 +149,7 @@ export function createGameServicesBackend(input) {
                     evidenceVerifier,
                     evidenceVerificationTimeoutMs,
                     purchaseGrantFinalizationTimeoutMs,
+                    deploymentTargetBindings,
                     ...(input.purchaseGrantFinalizer === undefined
                         ? {}
                         : { purchaseGrantFinalizer: input.purchaseGrantFinalizer }),
@@ -177,6 +180,7 @@ export function createGameServicesBackend(input) {
                     now,
                     evidenceVerifier,
                     evidenceVerificationTimeoutMs,
+                    deploymentTargetBindings,
                 });
                 await analytics.track({
                     name: claim.granted ? 'rewarded_ad_granted' : 'rewarded_ad_rejected',
@@ -313,14 +317,44 @@ export function createGameServicesHttpFetchHandler(handler, options = {}) {
         }
     };
 }
+const gameServicesDeploymentTargetPlatforms = new Set([
+    'android',
+    'ios',
+    'ait',
+    'verse8',
+]);
+function resolveDeploymentTargetBindings(input) {
+    const bindings = {};
+    for (const [platformTarget, deploymentTarget] of Object.entries(input ?? {})) {
+        if (!gameServicesDeploymentTargetPlatforms.has(platformTarget)) {
+            throw new Error(`Unsupported deployment target binding platform: ${platformTarget}.`);
+        }
+        assertGameServicesDeploymentTarget(deploymentTarget);
+        bindings[platformTarget] = deploymentTarget;
+    }
+    return bindings;
+}
+function bindRequestDeploymentTarget(request, bindings) {
+    const deploymentTarget = bindings[request.target] ?? request.target;
+    if (request.deploymentTarget !== undefined
+        && request.deploymentTarget !== deploymentTarget) {
+        throw new Error(`deploymentTarget must match the backend binding for ${request.target}.`);
+    }
+    return deploymentTarget === request.target || request.deploymentTarget === deploymentTarget
+        ? request
+        : { ...request, deploymentTarget };
+}
 async function verifyPurchaseWithStore(input, context) {
-    const request = assertVerifyPurchaseRequest(input);
+    const request = bindRequestDeploymentTarget(assertVerifyPurchaseRequest(input), context.deploymentTargetBindings);
     const retryIdentity = {
         source: 'purchase',
         playerId: request.playerId,
         idempotencyKey: request.idempotencyKey,
         grantId: request.productId,
         target: request.target,
+        ...(request.deploymentTarget === undefined
+            ? {}
+            : { deploymentTarget: request.deploymentTarget }),
     };
     const completeExistingRetry = async (transaction) => {
         if (!matchesEntitlementRetry(transaction, retryIdentity)) {
@@ -350,7 +384,7 @@ async function verifyPurchaseWithStore(input, context) {
             reason: 'UNKNOWN_PRODUCT',
         });
     }
-    const platformProductId = product.platformProductIds[request.target];
+    const platformProductId = resolveProductPlatformId(product, request.deploymentTarget ?? request.target);
     if (platformProductId === undefined) {
         return assertVerifyPurchaseResponse({
             verified: false,
@@ -394,6 +428,9 @@ async function verifyPurchaseWithStore(input, context) {
         payload: {
             ...verificationPayload,
             target: request.target,
+            ...(request.deploymentTarget === undefined
+                ? {}
+                : { deploymentTarget: request.deploymentTarget }),
             productId: request.productId,
             productType: product.type,
             platformProductId,
@@ -569,13 +606,16 @@ function createStoredPurchaseRequest(request, transaction) {
     };
 }
 async function claimAdRewardWithStore(input, context) {
-    const request = assertClaimAdRewardRequest(input);
+    const request = bindRequestDeploymentTarget(assertClaimAdRewardRequest(input), context.deploymentTargetBindings);
     const retryIdentity = {
         source: 'ad_reward',
         playerId: request.playerId,
         idempotencyKey: request.idempotencyKey,
         grantId: request.placementId,
         target: request.target,
+        ...(request.deploymentTarget === undefined
+            ? {}
+            : { deploymentTarget: request.deploymentTarget }),
     };
     const existing = await findEntitlementTransactionByIdempotency(context.store, retryIdentity);
     if (existing !== undefined) {
@@ -600,7 +640,7 @@ async function claimAdRewardWithStore(input, context) {
             reason: placement === undefined ? 'UNKNOWN_PLACEMENT' : 'NOT_REWARDED_PLACEMENT',
         });
     }
-    const platformPlacementId = placement.platformPlacementIds[request.target];
+    const platformPlacementId = resolveAdPlacementPlatformId(placement, request.deploymentTarget ?? request.target);
     const verification = await verifyEvidence((signal) => {
         return context.evidenceVerifier.verifyAdReward({
             request,
@@ -622,6 +662,9 @@ async function claimAdRewardWithStore(input, context) {
     const payload = {
         ...verification.payload,
         target: request.target,
+        ...(request.deploymentTarget === undefined
+            ? {}
+            : { deploymentTarget: request.deploymentTarget }),
         placementId: request.placementId,
         rewardType: placement.reward.type,
         amount: placement.reward.amount,
@@ -908,7 +951,8 @@ function matchesEntitlementRetry(transaction, identity) {
         && transaction.playerId === identity.playerId
         && transaction.idempotencyKey === identity.idempotencyKey
         && transaction.grantId === identity.grantId
-        && transaction.payload.target === identity.target;
+        && transaction.payload.target === identity.target
+        && transaction.payload.deploymentTarget === identity.deploymentTarget;
 }
 function resolveEvidenceVerificationTimeout(timeoutMs) {
     const resolved = timeoutMs ?? 10000;

package/dist/types.d.ts

@@ -12,6 +12,8 @@ export type EntitlementLedgerSource = 'purchase' | 'ad_reward' | 'admin';
 export type EntitlementLedgerPayload = Record<string, string | number | boolean>;
 export interface VerifyPurchaseRequest {
   readonly target: GameServicesStoreTarget;
+  /** Deployment config key used to resolve game-owned platform product identifiers. */
+  readonly deploymentTarget?: string;
   readonly playerId: string;
   readonly productId: LogicalProductId;
   readonly platformTransactionId: string;
@@ -35,6 +37,8 @@ export interface PurchaseGrantFinalization {
 }
 export interface ClaimAdRewardRequest {
   readonly target: GameServicesAdRewardTarget;
+  /** Deployment config key used to resolve game-owned platform placement identifiers. */
+  readonly deploymentTarget?: string;
   readonly playerId: string;
   readonly placementId: LogicalAdPlacementId;
   /** Platform evidence identity; AIT uses the game-issued reward correlation identifier. */
@@ -100,3 +104,4 @@ export declare function assertEntitlementLedgerGrant(input: EntitlementLedgerGra
 export declare function assertEntitlementLedgerResult(input: EntitlementLedgerResult): EntitlementLedgerResult;
 export declare function assertProductGrantTransaction(input: ProductGrantTransaction): ProductGrantTransaction;
 export declare function assertLeaderboardScoreTransaction(input: LeaderboardScoreTransaction): LeaderboardScoreTransaction;
+export declare function assertGameServicesDeploymentTarget(input: unknown): asserts input is string;

package/dist/types.js

@@ -1,6 +1,7 @@
 export function assertVerifyPurchaseRequest(input) {
     assertRecord(input, 'VerifyPurchaseRequest');
     assertStoreTarget(input.target);
+    assertOptionalGameServicesDeploymentTarget(input.deploymentTarget);
     assertNonEmptyString(input.playerId, 'playerId');
     assertNonEmptyString(input.productId, 'productId');
     assertNonEmptyString(input.platformTransactionId, 'platformTransactionId');
@@ -44,6 +45,7 @@ export function assertPurchaseGrantFinalization(input) {
 export function assertClaimAdRewardRequest(input) {
     assertRecord(input, 'ClaimAdRewardRequest');
     assertAdRewardTarget(input.target);
+    assertOptionalGameServicesDeploymentTarget(input.deploymentTarget);
     assertNonEmptyString(input.playerId, 'playerId');
     assertNonEmptyString(input.placementId, 'placementId');
     assertOptionalNonEmptyString(input.platformImpressionId, 'platformImpressionId');
@@ -135,6 +137,34 @@ function assertAdRewardTarget(input) {
         throw new Error('target must be android, ios, ait, or verse8.');
     }
 }
+export function assertGameServicesDeploymentTarget(input) {
+    if (typeof input !== 'string'
+        || input.length > 64
+        || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/u.test(input)
+        || reservedDeploymentTargetNames.has(input)) {
+        throw new Error('deploymentTarget must use lowercase kebab-case and avoid reserved names.');
+    }
+}
+function assertOptionalGameServicesDeploymentTarget(input) {
+    if (input === undefined) {
+        return;
+    }
+    assertGameServicesDeploymentTarget(input);
+}
+const reservedDeploymentTargetNames = new Set([
+    'aux',
+    'browser',
+    'con',
+    'devvit',
+    'index',
+    'msstore',
+    'nul',
+    'prn',
+    'constructor',
+    'prototype',
+    ...Array.from({ length: 9 }, (_, index) => `com${String(index + 1)}`),
+    ...Array.from({ length: 9 }, (_, index) => `lpt${String(index + 1)}`),
+]);
 function assertLeaderboardTarget(input) {
     if (input !== 'browser'
         && input !== 'android'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/game-services",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "description": "Client, contract, server, store, and test helpers for authoritative mpgd game services.",
   "license": "MIT",
   "repository": {
@@ -53,6 +53,10 @@
       "types": "./dist/apps-in-toss-evidence-verification-conformance.d.ts",
       "default": "./dist/apps-in-toss-evidence-verification-conformance.js"
     },
+    "./apps-in-toss-partner-api": {
+      "types": "./dist/apps-in-toss-partner-api.d.ts",
+      "default": "./dist/apps-in-toss-partner-api.js"
+    },
     "./client": {
       "types": "./dist/client.d.ts",
       "default": "./dist/client.js"
@@ -122,9 +126,9 @@
     "@orpc/client": "2.0.0-beta.14",
     "@orpc/contract": "2.0.0-beta.14",
     "@orpc/server": "2.0.0-beta.14",
-    "@mpgd/catalog": "0.5.0",
-    "@mpgd/platform": "0.7.0",
-    "@mpgd/analytics": "0.3.7"
+    "@mpgd/analytics": "0.3.8",
+    "@mpgd/catalog": "0.5.2",
+    "@mpgd/platform": "0.8.0"
   },
   "devDependencies": {
     "ttsc": "0.18.4",
@@ -140,6 +144,6 @@
     "lint": "ttsc --noEmit",
     "format": "ttsc format",
     "fix": "ttsc fix",
-    "test": "cd ../.. && node tools/run-ttsx.mjs packages/game-services/src/client.test.ts && node tools/run-ttsx.mjs packages/game-services/src/runtime.test.ts && node tools/run-ttsx.mjs packages/game-services/src/types.test.ts && node tools/run-ttsx.mjs packages/game-services/src/server.test.ts && node tools/run-ttsx.mjs packages/game-services/src/google-play-purchase.test.ts && node tools/run-ttsx.mjs packages/game-services/src/platform-order.test.ts && node tools/run-ttsx.mjs packages/game-services/src/progress-link.test.ts && node tools/run-ttsx.mjs packages/game-services/src/notification-delivery.test.ts && node tools/run-ttsx.mjs packages/game-services/src/admob-ssv.test.ts && node tools/run-ttsx.mjs packages/game-services/src/app-store-verifier.test.ts && node tools/run-ttsx.mjs packages/game-services/src/apps-in-toss-evidence-verification-conformance.test.ts && node tools/run-ttsx.mjs packages/game-services/src/verified-leaderboard.test.ts && node tools/run-ttsx.mjs packages/game-services/src/verified-leaderboard-conformance.test.ts && node tools/run-ttsx.mjs packages/game-services/src/verified-leaderboard-durability-conformance.test.ts && node tools/run-ttsx.mjs packages/game-services/src/verified-leaderboard-transport.test.ts"
+    "test": "cd ../.. && node tools/run-ttsx.mjs packages/game-services/src/client.test.ts && node tools/run-ttsx.mjs packages/game-services/src/runtime.test.ts && node tools/run-ttsx.mjs packages/game-services/src/types.test.ts && node tools/run-ttsx.mjs packages/game-services/src/server.test.ts && node tools/run-ttsx.mjs packages/game-services/src/google-play-purchase.test.ts && node tools/run-ttsx.mjs packages/game-services/src/platform-order.test.ts && node tools/run-ttsx.mjs packages/game-services/src/progress-link.test.ts && node tools/run-ttsx.mjs packages/game-services/src/notification-delivery.test.ts && node tools/run-ttsx.mjs packages/game-services/src/admob-ssv.test.ts && node tools/run-ttsx.mjs packages/game-services/src/app-store-verifier.test.ts && node tools/run-ttsx.mjs packages/game-services/src/apps-in-toss-evidence-verification-conformance.test.ts && node tools/run-ttsx.mjs packages/game-services/src/apps-in-toss-partner-api.test.ts && node tools/run-ttsx.mjs packages/game-services/src/verified-leaderboard.test.ts && node tools/run-ttsx.mjs packages/game-services/src/verified-leaderboard-conformance.test.ts && node tools/run-ttsx.mjs packages/game-services/src/verified-leaderboard-durability-conformance.test.ts && node tools/run-ttsx.mjs packages/game-services/src/verified-leaderboard-transport.test.ts"
   }
 }