@mpgd/platform 0.21.0 → 0.22.0

package/dist/commerce-conformance.d.ts

@@ -355,6 +355,14 @@ export interface CommerceConformanceContext extends CommerceConformanceFixtureCo
 export interface CommerceConformanceRunOptions {
   /** Supplies a provider over the caller's fake SDK; defaults to the fake store or the reference wallet. */
   readonly createProvider?: (context: CommerceConformanceContext) => CommerceConformanceHarness | Promise<CommerceConformanceHarness>;
+  /**
+  * Supplies the runtime under test over the harness provider, backend, and
+  * journal; defaults to the reference reconciler
+  * (`createCommerceConformanceRuntime`). The reference run an adaptive
+  * vector is derived from always uses the reference reconciler, so the
+  * derived expectations stay the RFC's regardless of the runtime under test.
+  */
+  readonly createRuntime?: (input: CreateCommerceConformanceRuntimeInput, context: CommerceConformanceContext) => CommerceConformanceRuntime | Promise<CommerceConformanceRuntime>;
   readonly playerId?: string;
   readonly titleId?: string;
 }

package/dist/commerce-conformance.js

@@ -1107,7 +1107,7 @@ async function runVectorIn(vector, options, family) {
     // A harness that cannot be built is a failed run, never a rejected promise.
     let execution;
     try {
-        execution = await prepareExecution(vector, options.createProvider ?? createCommerceConformanceHarness, ids);
+        execution = await prepareExecution(vector, options.createProvider ?? createCommerceConformanceHarness, ids, options.createRuntime);
     }
     catch (error) {
         return failed([
@@ -1200,7 +1200,7 @@ async function runVectorIn(vector, options, family) {
         ...(adaptive === undefined ? {} : { adaptive }),
     };
 }
-async function prepareExecution(vector, createHarness, ids) {
+async function prepareExecution(vector, createHarness, ids, createRuntime) {
     const clock = createCommerceConformanceClock();
     const journal = createCommerceConformanceJournal();
     const harnessRef = {};
@@ -1224,14 +1224,17 @@ async function prepareExecution(vector, createHarness, ids) {
     };
     const harness = await createHarness(context);
     harnessRef.current = harness;
-    const runtime = createCommerceConformanceRuntime({
+    const runtimeInput = {
         provider: harness.provider,
         backend,
         journal,
         clock,
         catalog: context.catalog,
         playerId: ids.playerId,
-    });
+    };
+    const runtime = createRuntime === undefined
+        ? createCommerceConformanceRuntime(runtimeInput)
+        : await createRuntime(runtimeInput, context);
     return { vector, harness, runtime, backend, journal, clock, adaptation };
 }
 /** Runs every step; a thrown step ends the run with a failure at that step. */

package/dist/commerce-contract.d.ts

@@ -1,4 +1,4 @@
-import type { CommerceCapabilities, LogicalProductId, PlatformEvidenceEnvelope, StarterLogicalProductId } from './index.js';
+import type { CommerceCapabilities, CommerceFinishOwner, LogicalProductId, PlatformEvidenceEnvelope, StarterLogicalProductId } from './index.js';
 /**
 * Commerce v2 client contract types (RFC "Client contract"). This module is
 * typia-free on purpose: `./index` references `CommerceProvider` for
@@ -199,7 +199,13 @@ export interface CommerceProvider {
   requestPurchase(input: RequestPurchaseInput): Promise<RequestPurchaseResult>;
   /** Purchases the store still reports as unfinished. */
   getAvailablePurchases(input?: GetAvailablePurchasesInput): Promise<readonly StorePurchase[]>;
-  /** Required when `lifecycle.finish` is 'client' or 'host'. */
+  /**
+  * Required when `lifecycle.finish` is 'client' or 'host'. Idempotent per
+  * transaction: the reconciler calls it again after a crash between a
+  * successful finish and its journal write, and on every pass while a
+  * finish keeps failing, so finishing an already finished transaction
+  * answers `{ finished: true }` rather than failing.
+  */
   finishTransaction?(input: FinishTransactionInput): Promise<FinishTransactionResult>;
   /** Asks the store to resynchronize, for example `AppStore.sync`. */
   restorePurchases?(): Promise<void>;
@@ -219,4 +225,27 @@ export interface ActiveSubscription {
   readonly expiresAt: IsoTimestamp;
   readonly autoRenew: boolean;
 }
+/** What the backend accepts for one store (RFC "Provider capabilities endpoint"). */
+export interface CommerceServiceStoreCapabilities {
+  readonly store: StoreId;
+  /** Evidence schemas the backend routes for this store. */
+  readonly schemas: readonly NonEmptyString[];
+  /** Who finishes a granted purchase of this store, as the backend expects it. */
+  readonly finish: CommerceFinishOwner;
+  readonly purchase: {
+    readonly consumable: boolean;
+    readonly durable: boolean;
+    readonly subscription: boolean;
+  };
+}
+/**
+* The backend's published commerce capabilities (RFC "Provider capabilities
+* endpoint"): the protocol version it speaks and one row per store its
+* evidence registry accepts. The client runtime compares it with its
+* provider's capability block at start.
+*/
+export interface CommerceServiceCapabilities {
+  readonly commerceProtocolVersion: NonEmptyString;
+  readonly stores: readonly CommerceServiceStoreCapabilities[];
+}
 export {};

package/dist/commerce.d.ts

@@ -1,6 +1,6 @@
 import { type tags } from 'typia';
 import { PlatformOperationError, type CommerceAdapter, type CommerceCapabilities } from './index.js';
-import type { ActiveSubscription, CommerceErrorCode, CommerceErrorInfo, CommerceEvent, CommerceLogicalProductId, CommerceProvider, FetchProductsInput, FinishTransactionInput, FinishTransactionResult, GetAvailablePurchasesInput, IsoTimestamp, NonEmptyString, NonNegativeInteger, PositiveQuantity, PurchaseKind, RequestPurchaseInput, RequestPurchaseResult, StoreId, StoreProduct, StorePurchase } from './commerce-contract.js';
+import type { ActiveSubscription, CommerceErrorCode, CommerceErrorInfo, CommerceEvent, CommerceLogicalProductId, CommerceProvider, CommerceServiceCapabilities, FetchProductsInput, FinishTransactionInput, FinishTransactionResult, GetAvailablePurchasesInput, IsoTimestamp, NonEmptyString, NonNegativeInteger, PositiveQuantity, PurchaseKind, RequestPurchaseInput, RequestPurchaseResult, StoreId, StoreProduct, StorePurchase } from './commerce-contract.js';
 export { createUnsupportedCommerceCapabilities, deriveLegacyCommerceCapabilities, type LegacyCommerceCapabilities, } from './commerce-capabilities.js';
 export type { CommerceAccountBindingPolicy, CommerceAuthorityCapabilities, CommerceCapabilities, CommerceCatalogCapabilities, CommerceEvidenceAuthority, CommerceFinishOwner, CommerceLifecycleCapabilities, CommercePurchaseCapabilities, } from './index.js';
 /**
@@ -11,7 +11,7 @@ export type { CommerceAccountBindingPolicy, CommerceAuthorityCapabilities, Comme
 */
 export declare const commerceProtocolVersion: '2.0.0-draft.1';
 export declare const commerceProtocol: 'mpgd.commerce.v2';
-export type { ActiveSubscription, ActiveSubscriptionState, CommerceErrorCode, CommerceErrorInfo, CommerceEvent, CommerceLogicalProductId, CommerceProvider, FetchProductsInput, FetchProductsType, FinishTransactionInput, FinishTransactionResult, GetAvailablePurchasesInput, PurchaseKind, PurchaseSource, RequestPurchaseInput, RequestPurchaseResult, StoreId, StoreOffer, StorePrice, StoreProduct, StorePurchase, StorePurchaseAccountBinding, StorePurchaseState, } from './commerce-contract.js';
+export type { ActiveSubscription, ActiveSubscriptionState, CommerceErrorCode, CommerceErrorInfo, CommerceEvent, CommerceLogicalProductId, CommerceProvider, CommerceServiceCapabilities, CommerceServiceStoreCapabilities, FetchProductsInput, FetchProductsType, FinishTransactionInput, FinishTransactionResult, GetAvailablePurchasesInput, PurchaseKind, PurchaseSource, RequestPurchaseInput, RequestPurchaseResult, StoreId, StoreOffer, StorePrice, StoreProduct, StorePurchase, StorePurchaseAccountBinding, StorePurchaseState, } from './commerce-contract.js';
 export declare const commerceErrorCodes: readonly ["USER_CANCELLED", "OUTCOME_UNKNOWN", "ALREADY_OWNED", "IN_PROGRESS", "ITEM_UNAVAILABLE", "NOT_PREPARED", "NETWORK", "STORE_UNAVAILABLE", "CONFIGURATION_REQUIRED", "ACTION_REQUIRED", "ACCOUNT_BINDING_REQUIRED", "INSUFFICIENT_BALANCE", "INVALID_RESPONSE", "UNKNOWN"];
 /** Bridge event envelope; `sequence` is per session and starts at 0. */
 export interface CommerceEventEnvelope {
@@ -250,8 +250,9 @@ export interface DerivedPurchaseIdempotencyKeyInput {
 * the same key: `store:<storeId>:<transactionId>` by default, with each
 * component percent-encoded (`encodeURIComponent`) so ids containing `:`
 * cannot collide, and the forms v1 ledgers already use for Google Play
-* (`play-token-sha256:<hex>`) and Apps in Toss (`apps-in-toss:purchase:<orderId>`),
-* which stay byte-identical.
+* (`play-token-sha256:<hex>`) and Apps in Toss
+* (`apps-in-toss:purchase:<encodeURIComponent(orderId)>`), which stay
+* byte-identical.
 */
 export declare function createDerivedPurchaseIdempotencyKey(input: DerivedPurchaseIdempotencyKeyInput): Promise<string>;
 /** Byte-for-byte the v1 `createGooglePlayTokenTransactionId` form; A4 replaces the two copies with this helper. */
@@ -292,6 +293,8 @@ export declare const isActiveSubscription: (input: unknown) => input is ActiveSu
 export declare const assertFetchProductsInput: (input: unknown) => FetchProductsInput;
 export declare const assertCommerceCapabilities: (input: unknown) => CommerceCapabilities;
 export declare const isCommerceCapabilities: (input: unknown) => input is CommerceCapabilities;
+export declare const assertCommerceServiceCapabilities: (input: unknown) => CommerceServiceCapabilities;
+export declare const isCommerceServiceCapabilities: (input: unknown) => input is CommerceServiceCapabilities;
 export declare const assertCommerceErrorInfo: (input: unknown) => CommerceErrorInfo;
 export declare const assertCreditOffer: (input: unknown) => CreditOffer;
 export declare const assertCreditSpendInput: (input: unknown) => CreditSpendInput;

package/dist/commerce.js

@@ -204,8 +204,9 @@ export function assertRequestPurchaseSupported(capabilities, input, kind) {
  * the same key: `store:<storeId>:<transactionId>` by default, with each
  * component percent-encoded (`encodeURIComponent`) so ids containing `:`
  * cannot collide, and the forms v1 ledgers already use for Google Play
- * (`play-token-sha256:<hex>`) and Apps in Toss (`apps-in-toss:purchase:<orderId>`),
- * which stay byte-identical.
+ * (`play-token-sha256:<hex>`) and Apps in Toss
+ * (`apps-in-toss:purchase:<encodeURIComponent(orderId)>`), which stay
+ * byte-identical.
  */
 export async function createDerivedPurchaseIdempotencyKey(input) {
     const store = readIdentifier(input.store, 128);
@@ -220,7 +221,8 @@ export async function createDerivedPurchaseIdempotencyKey(input) {
         throw new TypeError('Derived purchase keys require a transaction id.');
     }
     if (store === 'apps-in-toss') {
-        return `apps-in-toss:purchase:${transactionId}`;
+        // Byte for byte the v1 `createAppsInTossPurchaseIdempotencyKey` form.
+        return `apps-in-toss:purchase:${encodeURIComponent(transactionId)}`;
     }
     return `store:${encodeURIComponent(store)}:${encodeURIComponent(transactionId)}`;
 }
@@ -3307,6 +3309,207 @@ export const isCommerceCapabilities = (() => {
     }));
     return (input, _exceptionable = true) => "object" === typeof input && null !== input && _io0(input, true);
 })();
+export const assertCommerceServiceCapabilities = (() => {
+    const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.commerceProtocolVersion && (1 <= input.commerceProtocolVersion.length || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssertEquals",
+        path: _path + ".commerceProtocolVersion",
+        expected: "string & CommerceMinLength<1>",
+        value: input.commerceProtocolVersion
+    }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssertEquals",
+        path: _path + ".commerceProtocolVersion",
+        expected: "(string & CommerceMinLength<1>)",
+        value: input.commerceProtocolVersion
+    }, _errorFactory)) && ((Array.isArray(input.stores) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssertEquals",
+        path: _path + ".stores",
+        expected: "ReadonlyArray<CommerceServiceStoreCapabilities>",
+        value: input.stores
+    }, _errorFactory)) && input.stores.every((elem, _index3) => ("object" === typeof elem && null !== elem || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssertEquals",
+        path: _path + ".stores[" + _index3 + "]",
+        expected: "CommerceServiceStoreCapabilities",
+        value: elem
+    }, _errorFactory)) && _ao1(elem, _path + ".stores[" + _index3 + "]", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssertEquals",
+        path: _path + ".stores[" + _index3 + "]",
+        expected: "CommerceServiceStoreCapabilities",
+        value: elem
+    }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssertEquals",
+        path: _path + ".stores",
+        expected: "ReadonlyArray<CommerceServiceStoreCapabilities>",
+        value: input.stores
+    }, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+        if (["commerceProtocolVersion", "stores"].some(prop => key === prop))
+            return true;
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+            expected: "undefined",
+            value: value
+        }, _errorFactory);
+    })));
+    const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.store && (1 <= input.store.length || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssertEquals",
+        path: _path + ".store",
+        expected: "string & CommerceMinLength<1>",
+        value: input.store
+    }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssertEquals",
+        path: _path + ".store",
+        expected: "(string & CommerceMinLength<1>)",
+        value: input.store
+    }, _errorFactory)) && ((Array.isArray(input.schemas) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssertEquals",
+        path: _path + ".schemas",
+        expected: "ReadonlyArray<NonEmptyString>",
+        value: input.schemas
+    }, _errorFactory)) && input.schemas.every((elem, _index4) => "string" === typeof elem && (1 <= elem.length || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssertEquals",
+        path: _path + ".schemas[" + _index4 + "]",
+        expected: "string & CommerceMinLength<1>",
+        value: elem
+    }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssertEquals",
+        path: _path + ".schemas[" + _index4 + "]",
+        expected: "(string & CommerceMinLength<1>)",
+        value: elem
+    }, _errorFactory)) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssertEquals",
+        path: _path + ".schemas",
+        expected: "ReadonlyArray<NonEmptyString>",
+        value: input.schemas
+    }, _errorFactory)) && ("client" === input.finish || "host" === input.finish || "none" === input.finish || "server" === input.finish || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssertEquals",
+        path: _path + ".finish",
+        expected: "(\"client\" | \"host\" | \"none\" | \"server\")",
+        value: input.finish
+    }, _errorFactory)) && (("object" === typeof input.purchase && null !== input.purchase || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssertEquals",
+        path: _path + ".purchase",
+        expected: "{ readonly consumable: boolean; readonly durable: boolean; readonly subscription: boolean; }",
+        value: input.purchase
+    }, _errorFactory)) && _ao2(input.purchase, _path + ".purchase", true && _exceptionable) || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssertEquals",
+        path: _path + ".purchase",
+        expected: "{ readonly consumable: boolean; readonly durable: boolean; readonly subscription: boolean; }",
+        value: input.purchase
+    }, _errorFactory)) && (4 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+        if (["store", "schemas", "finish", "purchase"].some(prop => key === prop))
+            return true;
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+            expected: "undefined",
+            value: value
+        }, _errorFactory);
+    })));
+    const _ao2 = (input, _path, _exceptionable = true) => ("boolean" === typeof input.consumable || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssertEquals",
+        path: _path + ".consumable",
+        expected: "boolean",
+        value: input.consumable
+    }, _errorFactory)) && ("boolean" === typeof input.durable || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssertEquals",
+        path: _path + ".durable",
+        expected: "boolean",
+        value: input.durable
+    }, _errorFactory)) && ("boolean" === typeof input.subscription || _assertGuard_1._assertGuard(_exceptionable, {
+        method: "typia.createAssertEquals",
+        path: _path + ".subscription",
+        expected: "boolean",
+        value: input.subscription
+    }, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+        if (["consumable", "durable", "subscription"].some(prop => key === prop))
+            return true;
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return _assertGuard_1._assertGuard(_exceptionable, {
+            method: "typia.createAssertEquals",
+            path: _path + _accessExpressionAsString_1._accessExpressionAsString(key),
+            expected: "undefined",
+            value: value
+        }, _errorFactory);
+    })));
+    const _io0 = (input, _exceptionable = true) => "string" === typeof input.commerceProtocolVersion && 1 <= input.commerceProtocolVersion.length && (Array.isArray(input.stores) && input.stores.every((elem, _index1) => "object" === typeof elem && null !== elem && _io1(elem, true && _exceptionable))) && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+        if (["commerceProtocolVersion", "stores"].some(prop => key === prop))
+            return true;
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return false;
+    }));
+    const _io1 = (input, _exceptionable = true) => "string" === typeof input.store && 1 <= input.store.length && (Array.isArray(input.schemas) && input.schemas.every((elem, _index2) => "string" === typeof elem && 1 <= elem.length)) && ("client" === input.finish || "host" === input.finish || "none" === input.finish || "server" === input.finish) && ("object" === typeof input.purchase && null !== input.purchase && _io2(input.purchase, true && _exceptionable)) && (4 === Object.keys(input).length || Object.keys(input).every(key => {
+        if (["store", "schemas", "finish", "purchase"].some(prop => key === prop))
+            return true;
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return false;
+    }));
+    const _io2 = (input, _exceptionable = true) => "boolean" === typeof input.consumable && "boolean" === typeof input.durable && "boolean" === typeof input.subscription && (3 === Object.keys(input).length || Object.keys(input).every(key => {
+        if (["consumable", "durable", "subscription"].some(prop => key === prop))
+            return true;
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return false;
+    }));
+    const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _io0(input, true);
+    let _errorFactory;
+    return (input, errorFactory) => {
+        if (false === __is(input)) {
+            _errorFactory = errorFactory;
+            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _assertGuard_1._assertGuard(true, {
+                method: "typia.createAssertEquals",
+                path: _path + "",
+                expected: "CommerceServiceCapabilities",
+                value: input
+            }, _errorFactory)) && _ao0(input, _path + "", true) || _assertGuard_1._assertGuard(true, {
+                method: "typia.createAssertEquals",
+                path: _path + "",
+                expected: "CommerceServiceCapabilities",
+                value: input
+            }, _errorFactory))(input, "$input", true);
+        }
+        return input;
+    };
+})();
+export const isCommerceServiceCapabilities = (() => {
+    const _io0 = (input, _exceptionable = true) => "string" === typeof input.commerceProtocolVersion && 1 <= input.commerceProtocolVersion.length && (Array.isArray(input.stores) && input.stores.every((elem, _index1) => "object" === typeof elem && null !== elem && _io1(elem, true && _exceptionable))) && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+        if (["commerceProtocolVersion", "stores"].some(prop => key === prop))
+            return true;
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return false;
+    }));
+    const _io1 = (input, _exceptionable = true) => "string" === typeof input.store && 1 <= input.store.length && (Array.isArray(input.schemas) && input.schemas.every((elem, _index2) => "string" === typeof elem && 1 <= elem.length)) && ("client" === input.finish || "host" === input.finish || "none" === input.finish || "server" === input.finish) && ("object" === typeof input.purchase && null !== input.purchase && _io2(input.purchase, true && _exceptionable)) && (4 === Object.keys(input).length || Object.keys(input).every(key => {
+        if (["store", "schemas", "finish", "purchase"].some(prop => key === prop))
+            return true;
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return false;
+    }));
+    const _io2 = (input, _exceptionable = true) => "boolean" === typeof input.consumable && "boolean" === typeof input.durable && "boolean" === typeof input.subscription && (3 === Object.keys(input).length || Object.keys(input).every(key => {
+        if (["consumable", "durable", "subscription"].some(prop => key === prop))
+            return true;
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return false;
+    }));
+    return (input, _exceptionable = true) => "object" === typeof input && null !== input && _io0(input, true);
+})();
 export const assertCommerceErrorInfo = (() => {
     const _iv0 = new Set(["ACCOUNT_BINDING_REQUIRED", "ACTION_REQUIRED", "ALREADY_OWNED", "CONFIGURATION_REQUIRED", "INSUFFICIENT_BALANCE", "INVALID_RESPONSE", "IN_PROGRESS", "ITEM_UNAVAILABLE", "NETWORK", "NOT_PREPARED", "OUTCOME_UNKNOWN", "STORE_UNAVAILABLE", "UNKNOWN", "USER_CANCELLED"]);
     const _av0 = new Set(["ACCOUNT_BINDING_REQUIRED", "ACTION_REQUIRED", "ALREADY_OWNED", "CONFIGURATION_REQUIRED", "INSUFFICIENT_BALANCE", "INVALID_RESPONSE", "IN_PROGRESS", "ITEM_UNAVAILABLE", "NETWORK", "NOT_PREPARED", "OUTCOME_UNKNOWN", "STORE_UNAVAILABLE", "UNKNOWN", "USER_CANCELLED"]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/platform",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "Shared platform gateway, monetization, ads, leaderboard, identity, lifecycle, and storage contracts for mpgd games.",
   "license": "MIT",
   "repository": {