@mpgd/game-services 0.13.1 → 0.14.0

package/dist/index.d.ts

@@ -6,6 +6,7 @@ export * from './client';
 export * from './contract';
 export * from './evidence-verification';
 export * from './google-play-purchase';
+export * from './microsoft-store-identity';
 export * from './microsoft-store-purchase';
 export * from './notification-delivery';
 export * from './platform-order';

package/dist/index.js

@@ -6,6 +6,7 @@ export * from './client';
 export * from './contract';
 export * from './evidence-verification';
 export * from './google-play-purchase';
+export * from './microsoft-store-identity';
 export * from './microsoft-store-purchase';
 export * from './notification-delivery';
 export * from './platform-order';

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

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

package/dist/microsoft-store-identity.js

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

package/dist/notification-delivery.js

@@ -9,6 +9,8 @@ const platformTargets = new Set([
     'telegram',
     'tauri',
     'microsoft-store',
+    'wechat',
+    'tiktok',
 ]);
 const notificationTopics = new Set([
     'daily-ready',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/game-services",
-  "version": "0.13.1",
+  "version": "0.14.0",
   "description": "Client, contract, server, store, and test helpers for authoritative mpgd game services.",
   "license": "MIT",
   "repository": {
@@ -73,6 +73,10 @@
       "types": "./dist/google-play-purchase.d.ts",
       "default": "./dist/google-play-purchase.js"
     },
+    "./microsoft-store-identity": {
+      "types": "./dist/microsoft-store-identity.d.ts",
+      "default": "./dist/microsoft-store-identity.js"
+    },
     "./microsoft-store-purchase": {
       "types": "./dist/microsoft-store-purchase.d.ts",
       "default": "./dist/microsoft-store-purchase.js"
@@ -130,9 +134,9 @@
     "@orpc/client": "2.0.0-beta.14",
     "@orpc/contract": "2.0.0-beta.14",
     "@orpc/server": "2.0.0-beta.14",
-    "@mpgd/analytics": "0.3.11",
-    "@mpgd/catalog": "0.7.1",
-    "@mpgd/platform": "0.11.0"
+    "@mpgd/analytics": "0.3.12",
+    "@mpgd/platform": "0.12.0",
+    "@mpgd/catalog": "0.7.2"
   },
   "devDependencies": {
     "ttsc": "0.18.4",
@@ -148,6 +152,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/microsoft-store-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"
+    "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/microsoft-store-purchase.test.ts && node tools/run-ttsx.mjs packages/game-services/src/microsoft-store-identity.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"
   }
 }