@mpgd/adapter-capacitor 0.14.0 → 0.16.1

package/README.md

@@ -366,6 +366,35 @@ is created, which is how a cold-start open reaches it.
   because FCM HTTP v1 cannot send to a Firebase installation id and the
   game-services FCM sender refuses them.
 
+## Crash reporting
+
+`createCapacitorPlatformGateway` exposes `gateway.crashReporter`
+(`@mpgd/platform/crash-reporting`), backed by Firebase Crashlytics when the
+shell has `@capacitor-firebase/crashlytics` 8.x
+(`mpgd target init capacitor --providers crash-reporting`). The adapter
+reaches the native plugin by its registered name, so the game does not
+depend on the npm package; without the plugin the reporter reports
+`not-installed` and does nothing. With it, uncaught WebView errors and
+unhandled rejections are reported as non-fatal (once each, at most 8 per
+session).
+
+```ts
+const gateway = createCapacitorPlatformGateway({
+  target: 'android',
+  appVersion,
+  buildId,
+  // Optional: extra non-personal keys, or turn the WebView capture off.
+  crashReporting: { context: { content_version: 12 }, captureGlobalErrors: true },
+});
+await gateway.crashReporter?.recordError(error);
+await gateway.crashReporter?.setCollectionEnabled(playerAllowsCrashReports);
+```
+
+`crashReporting: false` leaves `crashReporter` out; `crashReporting: { reporter }`
+uses another `CrashReporter`; `crashReporting: { requireConsent: true }` holds
+JavaScript reports until `setCollectionEnabled(true)`. Setup, symbols, consent and the store privacy
+answers are in the [crash reporting guide](../../docs/CRASH_REPORTING.md).
+
 ## App Store server-side transaction signatures
 
 The server-side verifier lives in `@mpgd/game-services/app-store-server`

package/dist/crash-reporting.d.ts

@@ -0,0 +1,104 @@
+import { type CrashContextValue, type CrashErrorEventTarget, type CrashReporter, type CrashStackFrame } from '@mpgd/platform/crash-reporting';
+/** The name the native plugin registers with Capacitor. */
+export declare const capacitorCrashlyticsPluginName = "FirebaseCrashlytics";
+/** `CrashReporterStatus.provider` of the Capacitor reporter. */
+export declare const capacitorCrashReportingProvider = "firebase-crashlytics";
+type CrashlyticsKeyType = 'string' | 'boolean' | 'long' | 'double' | 'int' | 'float';
+/**
+* The calls the reporter makes on `@capacitor-firebase/crashlytics` 8.x
+* (`FirebaseCrashlyticsPlugin`); the adapter's tests check that the plugin's
+* own declarations satisfy it.
+*/
+export interface CapacitorCrashlyticsPlugin {
+  setCustomKey(options: {
+    readonly key: string;
+    readonly value: CrashContextValue;
+    readonly type: CrashlyticsKeyType;
+  }): Promise<void>;
+  log(options: {
+    readonly message: string;
+  }): Promise<void>;
+  setEnabled(options: {
+    readonly enabled: boolean;
+  }): Promise<void>;
+  /** iOS only; Android rejects it. */
+  isEnabled(): Promise<{
+    readonly enabled: boolean;
+  }>;
+  deleteUnsentReports(): Promise<void>;
+  recordException(options: {
+    readonly message: string;
+    readonly stacktrace?: CrashStackFrame[];
+  }): Promise<void>;
+}
+export interface CapacitorCrashReporterOptions {
+  readonly target: 'android' | 'ios';
+  readonly appVersion: string;
+  readonly buildId: string;
+  /**
+  * Extra non-personal context, for example the kit or content version.
+  * Filtered by `sanitizeCrashContext`; never put a player id here.
+  */
+  readonly context?: Readonly<Record<string, unknown>>;
+  /**
+  * Hold JavaScript reports and breadcrumbs until the player turns
+  * collection on with `setCollectionEnabled(true)` (now or in an earlier
+  * launch), for games that turn Crashlytics' automatic collection off until
+  * the player agrees (docs/CRASH_REPORTING.md#the-players-choice).
+  * Defaults to false.
+  */
+  readonly requireConsent?: boolean;
+  /**
+  * Keeps the player's last `setCollectionEnabled` choice across launches for
+  * the JavaScript side, which Android cannot read back from the SDK.
+  * Defaults to the WebView's `localStorage`; reads and writes never throw.
+  */
+  readonly collectionPreference?: CrashCollectionPreferenceStore;
+  /** Defaults to `Capacitor.isPluginAvailable`. */
+  readonly isPluginAvailable?: (name: string) => boolean;
+  /** Defaults to the plugin registered under `capacitorCrashlyticsPluginName`. */
+  readonly plugin?: CapacitorCrashlyticsPlugin;
+}
+/** Where the reporter keeps the player's collection choice between launches. */
+export interface CrashCollectionPreferenceStore {
+  read(): boolean | undefined;
+  write(enabled: boolean): void;
+}
+/** The default store: the WebView's `localStorage`, ignored when it is unavailable. */
+export declare function createLocalCrashCollectionPreferenceStore(): CrashCollectionPreferenceStore;
+/**
+* A `CrashReporter` backed by Firebase Crashlytics. Native crashes are
+* captured by the Crashlytics SDK on its own; this reporter adds non-fatal
+* reports for JavaScript errors, breadcrumbs, and the collection toggle.
+* Context keys (`mpgd_target`, `mpgd_build_id`, `mpgd_app_version`,
+* `mpgd_adapter`, and `options.context`) are set once, starting when the
+* reporter is created, so native crashes carry them too. When the first of
+* them fails (Firebase not configured) the reporter is `not-configured` and
+* later calls do nothing; a failing game key is skipped.
+*/
+export declare function createCapacitorCrashReporter(options: CapacitorCrashReporterOptions): CrashReporter;
+export interface CapacitorCrashReportingOptions extends Omit<CapacitorCrashReporterOptions, 'target' | 'appVersion' | 'buildId'> {
+  /** A reporter to use instead of the Crashlytics one. */
+  readonly reporter?: CrashReporter;
+  /**
+  * Report uncaught errors and unhandled rejections from the WebView.
+  * Defaults to true; only installed when the native plugin is present.
+  */
+  readonly captureGlobalErrors?: boolean;
+  /** Defaults to `globalThis` when it has `addEventListener`. */
+  readonly errorTarget?: CrashErrorEventTarget;
+}
+/**
+* The gateway's crash reporting: the reporter and, when the crash service is
+* present, the WebView error capture. `dispose` removes the listeners.
+*/
+export declare function createCapacitorGatewayCrashReporting(input: {
+  readonly target: 'android' | 'ios';
+  readonly appVersion: string;
+  readonly buildId: string;
+  readonly options: CapacitorCrashReportingOptions;
+}): {
+  readonly reporter: CrashReporter;
+  readonly dispose: () => void;
+};
+export {};

package/dist/crash-reporting.js

@@ -0,0 +1,286 @@
+import { Capacitor, registerPlugin } from '@capacitor/core';
+import { createUnavailableCrashReporter, formatCrashMessage, installCrashErrorCapture, normalizeCrashError, redactCrashText, sanitizeCrashContext, } from '@mpgd/platform/crash-reporting';
+// Firebase Crashlytics through the native plugin `@capacitor-firebase/crashlytics`
+// 8.x, installed into the shell by `mpgd target init capacitor --providers
+// crash-reporting`. The game bundle never imports the npm package: the
+// reporter reaches the native plugin by its registered name, so a game whose
+// shell lacks the plugin builds unchanged and gets an unavailable reporter.
+/** The name the native plugin registers with Capacitor. */
+export const capacitorCrashlyticsPluginName = 'FirebaseCrashlytics';
+/** `CrashReporterStatus.provider` of the Capacitor reporter. */
+export const capacitorCrashReportingProvider = 'firebase-crashlytics';
+const collectionPreferenceKey = 'mpgd.crashReporting.collectionEnabled';
+/** The default store: the WebView's `localStorage`, ignored when it is unavailable. */
+export function createLocalCrashCollectionPreferenceStore() {
+    const storage = () => {
+        try {
+            return globalThis.localStorage;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    return {
+        read() {
+            try {
+                const value = storage()?.getItem(collectionPreferenceKey);
+                return value === 'true' ? true : value === 'false' ? false : undefined;
+            }
+            catch {
+                return undefined;
+            }
+        },
+        write(enabled) {
+            try {
+                storage()?.setItem(collectionPreferenceKey, String(enabled));
+            }
+            catch {
+                // The SDK keeps the native choice; only the JavaScript gate forgets it.
+            }
+        },
+    };
+}
+const int32Min = -(2 ** 31);
+const int32Max = 2 ** 31 - 1;
+function keyType(value) {
+    if (typeof value === 'boolean') {
+        return 'boolean';
+    }
+    if (typeof value === 'number') {
+        // The Android plugin reads `long` and `int` values as a Java Integer, so
+        // an integer outside the int32 range goes as a double.
+        return Number.isInteger(value) && value >= int32Min && value <= int32Max ? 'int' : 'double';
+    }
+    return 'string';
+}
+/** A kit-set build fact: control characters removed and cut to 128 characters, not redacted. */
+function kitContextValue(value) {
+    return value.replace(/[\u0000-\u001f\u007f]/gu, ' ').slice(0, 128);
+}
+/**
+ * A `CrashReporter` backed by Firebase Crashlytics. Native crashes are
+ * captured by the Crashlytics SDK on its own; this reporter adds non-fatal
+ * reports for JavaScript errors, breadcrumbs, and the collection toggle.
+ * Context keys (`mpgd_target`, `mpgd_build_id`, `mpgd_app_version`,
+ * `mpgd_adapter`, and `options.context`) are set once, starting when the
+ * reporter is created, so native crashes carry them too. When the first of
+ * them fails (Firebase not configured) the reporter is `not-configured` and
+ * later calls do nothing; a failing game key is skipped.
+ */
+export function createCapacitorCrashReporter(options) {
+    const isPluginAvailable = options.isPluginAvailable
+        ?? ((name) => Capacitor.isPluginAvailable(name));
+    if (!isPluginAvailable(capacitorCrashlyticsPluginName)) {
+        return createUnavailableCrashReporter({
+            provider: capacitorCrashReportingProvider,
+            state: 'not-installed',
+        });
+    }
+    const plugin = options.plugin
+        ?? registerPlugin(capacitorCrashlyticsPluginName);
+    // Build ids are often long hex strings, which the token rule of
+    // `redactCrashText` would hide, so the kit's own keys are not redacted.
+    // `mpgd_target` goes first: its result tells whether Firebase is configured.
+    const kitContext = [
+        ['mpgd_build_id', kitContextValue(options.buildId)],
+        ['mpgd_app_version', kitContextValue(options.appVersion)],
+        ['mpgd_adapter', 'capacitor'],
+    ];
+    const gameContext = Object.entries(sanitizeCrashContext(options.context ?? {}))
+        .filter(([key]) => !key.startsWith('mpgd_'));
+    // The player's last choice gates JavaScript reports. The SDK keeps it
+    // across launches but Android cannot read it back, so the reporter keeps
+    // its own copy; on iOS the SDK's value fills a missing one.
+    const preference = options.collectionPreference ?? createLocalCrashCollectionPreferenceStore();
+    // A game-supplied store may throw; the choice then lives for the session
+    // only, and the native toggle still runs.
+    const readPreference = () => {
+        try {
+            return preference.read();
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const storedChoice = readPreference();
+    let collectionEnabled = storedChoice
+        ?? (options.requireConsent === true ? false : undefined);
+    // The stored choice is applied to the SDK again at every start: an earlier
+    // native setEnabled may have failed, leaving the SDK collecting after an
+    // opt-out or idle after an opt-in. Until the SDK takes it, the choice is
+    // retried with each report or breadcrumb.
+    let nativeChoicePending = storedChoice;
+    const applyNativeChoice = async () => {
+        const enabled = nativeChoicePending;
+        if (enabled === undefined || enabled !== collectionEnabled) {
+            return;
+        }
+        try {
+            await plugin.setEnabled({ enabled });
+            if (!enabled) {
+                await plugin.deleteUnsentReports();
+            }
+            if (nativeChoicePending === enabled) {
+                nativeChoicePending = undefined;
+            }
+        }
+        catch {
+            // Retried with the next report and at the next start.
+        }
+    };
+    let ready;
+    const prepare = () => {
+        ready ??= (async () => {
+            try {
+                await plugin.setCustomKey({ key: 'mpgd_target', value: options.target, type: 'string' });
+            }
+            catch {
+                return false;
+            }
+            for (const [key, value] of [...kitContext, ...gameContext]) {
+                try {
+                    await plugin.setCustomKey({ key, value, type: keyType(value) });
+                }
+                catch {
+                    // One key the SDK refuses does not stop reporting.
+                }
+            }
+            if (collectionEnabled === undefined && options.target === 'ios') {
+                try {
+                    const { enabled } = await plugin.isEnabled();
+                    collectionEnabled ??= enabled;
+                }
+                catch {
+                    // Unknown stays unknown.
+                }
+            }
+            await applyNativeChoice();
+            return true;
+        })();
+        return ready;
+    };
+    // Read after the wait: the player may turn collection off meanwhile.
+    const collecting = async () => {
+        if (!await prepare()) {
+            return false;
+        }
+        await applyNativeChoice();
+        return collectionEnabled !== false;
+    };
+    // Native crashes can happen before any JavaScript report, so the context
+    // keys are set right away. Keys stay on the device until a report is sent,
+    // so this does not bypass `requireConsent`.
+    void prepare();
+    return {
+        async getStatus() {
+            if (!await prepare()) {
+                return { provider: capacitorCrashReportingProvider, state: 'not-configured' };
+            }
+            let enabled = collectionEnabled;
+            if (enabled === undefined && options.target === 'ios') {
+                try {
+                    enabled = (await plugin.isEnabled()).enabled;
+                }
+                catch {
+                    enabled = undefined;
+                }
+            }
+            return {
+                provider: capacitorCrashReportingProvider,
+                state: 'available',
+                ...(enabled === undefined ? {} : { collectionEnabled: enabled }),
+            };
+        },
+        async recordError(error, recordOptions) {
+            if (!await collecting()) {
+                return false;
+            }
+            const normalized = normalizeCrashError(error);
+            try {
+                await plugin.recordException({
+                    message: formatCrashMessage(normalized, recordOptions?.source ?? 'game'),
+                    // The plugin's frames have no column.
+                    ...(normalized.frames.length === 0
+                        ? {}
+                        : {
+                            stacktrace: normalized.frames.map(({ columnNumber: _column, ...frame }) => frame),
+                        }),
+                });
+                return true;
+            }
+            catch {
+                // A report that cannot be recorded is dropped; game code never sees it.
+                return false;
+            }
+        },
+        async log(message) {
+            if (!await collecting()) {
+                return;
+            }
+            try {
+                await plugin.log({ message: redactCrashText(message) });
+            }
+            catch {
+                // Breadcrumbs are best effort.
+            }
+        },
+        async setCollectionEnabled(enabled) {
+            // Set before any wait, so a report racing with the toggle sees it.
+            collectionEnabled = enabled;
+            // This call applies the choice itself; only its failure leaves it
+            // pending.
+            nativeChoicePending = undefined;
+            try {
+                preference.write(enabled);
+            }
+            catch {
+                // Kept for this session; the SDK still persists the native choice.
+            }
+            if (!await prepare()) {
+                return;
+            }
+            try {
+                await plugin.setEnabled({ enabled });
+                if (!enabled) {
+                    await plugin.deleteUnsentReports();
+                }
+            }
+            catch {
+                // The session flag still gates JavaScript reports; the native choice
+                // stays pending and is retried with the next report and next start.
+                if (collectionEnabled === enabled) {
+                    nativeChoicePending = enabled;
+                }
+            }
+        },
+    };
+}
+/**
+ * The gateway's crash reporting: the reporter and, when the crash service is
+ * present, the WebView error capture. `dispose` removes the listeners.
+ */
+export function createCapacitorGatewayCrashReporting(input) {
+    const { reporter: customReporter, captureGlobalErrors, errorTarget, ...reporterOptions } = input.options;
+    const isPluginAvailable = reporterOptions.isPluginAvailable
+        ?? ((name) => Capacitor.isPluginAvailable(name));
+    const reporter = customReporter ?? createCapacitorCrashReporter({
+        ...reporterOptions,
+        isPluginAvailable,
+        target: input.target,
+        appVersion: input.appVersion,
+        buildId: input.buildId,
+    });
+    const present = customReporter !== undefined || isPluginAvailable(capacitorCrashlyticsPluginName);
+    const target = errorTarget ?? globalErrorTarget();
+    const dispose = present && captureGlobalErrors !== false && target !== undefined
+        ? installCrashErrorCapture({ reporter, target })
+        : () => { };
+    return { reporter, dispose };
+}
+function globalErrorTarget() {
+    const candidate = globalThis;
+    return typeof candidate.addEventListener === 'function'
+        && typeof candidate.removeEventListener === 'function'
+        ? candidate
+        : undefined;
+}

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 import { type PlatformGateway, type PlatformTarget, type ViewportAdapter } from '@mpgd/platform';
 import { type CapacitorAppEventsApi, type CapacitorIncomingUrlKind, type CapacitorVisibilitySource } from './app-events.js';
+import { type CapacitorCrashReportingOptions } from './crash-reporting.js';
 import { type CapacitorServiceProvider, type NativeBridge } from './providers.js';
+export { capacitorCrashlyticsPluginName, capacitorCrashReportingProvider, createCapacitorCrashReporter, createLocalCrashCollectionPreferenceStore, type CrashCollectionPreferenceStore, type CapacitorCrashlyticsPlugin, type CapacitorCrashReporterOptions, type CapacitorCrashReportingOptions, } from './crash-reporting.js';
 export { createCapacitorProviderRegistry, createDegradedCommerceCapabilities, createDegradedNotificationCapabilities, type CapacitorCommerceServiceProvider, type CapacitorNotificationServiceProvider, type CapacitorNotificationsV2Service, type CapacitorProviderCapabilitySnapshot, type CapacitorProviderRegistry, type CapacitorServiceProvider, type NativeBridge, } from './providers.js';
 export { assertCommerceBridgeResult, commerceV2InvalidPayloadBridgeErrorCode, commerceV2MethodUnsupportedBridgeErrorCode, createBridgeCommerceProvider, createCommerceProviderBridge, createCommerceServiceProvider, type CommerceProviderBridge, type CreateBridgeCommerceProviderInput, type CreateCommerceProviderBridgeInput, type CreateCommerceServiceProviderInput, } from './commerce-bridge.js';
 export { createStoreCommerceProvider, recoverableErrorCodes, type CreateStoreCommerceProviderInput, type StoreCommerceCapabilityOverrides, type StoreCommerceProductMapping, type StoreCommerceProvider, } from './store-commerce-provider.js';
@@ -26,4 +28,12 @@ export declare function createCapacitorPlatformGateway(input: {
   readonly historyBack?: () => void;
   readonly onAppEventError?: (error: unknown) => void;
   readonly viewport?: ViewportAdapter;
+  /**
+  * Crash reporting (`gateway.crashReporter`). By default the gateway uses
+  * Firebase Crashlytics when the shell has the native plugin (`--providers
+  * crash-reporting`) and then reports uncaught WebView errors too; without
+  * the plugin the reporter is unavailable and nothing is installed. `false`
+  * leaves `crashReporter` out.
+  */
+  readonly crashReporting?: CapacitorCrashReportingOptions | false;
 }): PlatformGateway;

package/dist/index.js

@@ -5,9 +5,11 @@ import { withShareIntentCheck } from '@mpgd/platform/routes';
 import { createCapacitorAppEvents, } from './app-events.js';
 import { namesOtherProtocol } from './bridge-events.js';
 import { createBridgeCommerceProvider } from './commerce-bridge.js';
+import { createCapacitorGatewayCrashReporting, } from './crash-reporting.js';
 import { assertProviderResponseData, createCapacitorProviderRegistry, } from './providers.js';
 import { assertNotificationsV2Served, externalActivityMethods } from './request-policy.js';
 import { createCapacitorViewport } from './viewport.js';
+export { capacitorCrashlyticsPluginName, capacitorCrashReportingProvider, createCapacitorCrashReporter, createLocalCrashCollectionPreferenceStore, } from './crash-reporting.js';
 export { createCapacitorProviderRegistry, createDegradedCommerceCapabilities, createDegradedNotificationCapabilities, } from './providers.js';
 export { assertCommerceBridgeResult, commerceV2InvalidPayloadBridgeErrorCode, commerceV2MethodUnsupportedBridgeErrorCode, createBridgeCommerceProvider, createCommerceProviderBridge, createCommerceServiceProvider, } from './commerce-bridge.js';
 export { createStoreCommerceProvider, recoverableErrorCodes, } from './store-commerce-provider.js';
@@ -99,10 +101,19 @@ export function createCapacitorPlatformGateway(input) {
     const viewport = input.viewport ?? createCapacitorViewport({
         ...(input.onAppEventError === undefined ? {} : { onError: input.onAppEventError }),
     });
+    const crashReporting = input.crashReporting === false
+        ? undefined
+        : createCapacitorGatewayCrashReporting({
+            target: input.target,
+            appVersion: input.appVersion,
+            buildId: input.buildId,
+            options: input.crashReporting ?? {},
+        });
     const launchedPurchaseHolds = new Set();
     const gatewayLifecycle = {
         ...lifecycle,
         async dispose() {
+            crashReporting?.dispose();
             try {
                 for (const finish of [...launchedPurchaseHolds]) {
                     finish();
@@ -284,6 +295,7 @@ export function createCapacitorPlatformGateway(input) {
             };
         },
         ...(commerce === undefined ? {} : { commerce }),
+        ...(crashReporting === undefined ? {} : { crashReporter: crashReporting.reporter }),
         identity: {
             getPlayer: () => request('identity.getPlayer', {}),
             getSession: () => request('identity.getSession', {}),

package/dist/reviews.d.ts

@@ -0,0 +1,8 @@
+import { Capacitor } from '@capacitor/core';
+import { type ReviewProvider } from '@mpgd/platform/reviews';
+export interface CapacitorReviewInput {
+  /** Mandatory distribution identity. Android alone must never imply Google Play. */
+  readonly store: 'google-play' | 'apple-app-store';
+  readonly appId?: string;
+}
+export declare function createCapacitorReviewProvider(input: CapacitorReviewInput, host?: Pick<typeof Capacitor, 'isNativePlatform' | 'isPluginAvailable' | 'getPlatform'>, plugin?: import("@capawesome/capacitor-app-review").AppReviewPlugin): ReviewProvider;

package/dist/reviews.js

@@ -0,0 +1,22 @@
+import { Capacitor } from '@capacitor/core';
+import { AppReview } from '@capawesome/capacitor-app-review';
+import { createReviewProvider } from '@mpgd/platform/reviews';
+export function createCapacitorReviewProvider(input, host = Capacitor, plugin = AppReview) {
+    if (input.store !== 'google-play' && input.store !== 'apple-app-store') {
+        throw new TypeError('Unsupported review store');
+    }
+    const matches = () => host.isNativePlatform() && host.isPluginAvailable('AppReview')
+        && host.getPlatform() === (input.store === 'google-play' ? 'android' : 'ios');
+    return createReviewProvider({
+        providerId: input.store,
+        isAvailable: matches,
+        requestNative: () => plugin.requestReview(),
+        // iOS listing navigation requires its registered Apple ID; never guess from bundleId.
+        ...(input.store === 'google-play' || input.appId && /^\d+$/.test(input.appId) ? {
+            openPage: async () => {
+                await plugin.openAppStore(input.store === 'apple-app-store' && input.appId ? { appId: input.appId } : undefined);
+                return true;
+            },
+        } : {}),
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/adapter-capacitor",
-  "version": "0.14.0",
+  "version": "0.16.1",
   "description": "Capacitor platform adapter for mpgd Android and iOS shells.",
   "license": "MIT",
   "repository": {
@@ -33,9 +33,17 @@
       "types": "./dist/admob.d.ts",
       "default": "./dist/admob.js"
     },
+    "./crash-reporting": {
+      "types": "./dist/crash-reporting.d.ts",
+      "default": "./dist/crash-reporting.js"
+    },
     "./notifications": {
       "types": "./dist/notifications.d.ts",
       "default": "./dist/notifications.js"
+    },
+    "./reviews": {
+      "types": "./dist/reviews.d.ts",
+      "default": "./dist/reviews.js"
     }
   },
   "files": [
@@ -43,38 +51,48 @@
   ],
   "dependencies": {
     "@capacitor/app": "8.1.1",
-    "@mpgd/bridge": "0.16.2",
-    "@mpgd/capacitor-game-services": "0.9.1",
-    "@mpgd/game-services": "0.30.0",
-    "@mpgd/target-config": "0.23.10",
-    "@mpgd/platform": "0.30.0"
+    "@mpgd/bridge": "0.16.4",
+    "@mpgd/capacitor-game-services": "0.9.3",
+    "@mpgd/game-services": "0.30.3",
+    "@mpgd/platform": "0.32.0",
+    "@mpgd/target-config": "0.24.1"
   },
   "peerDependencies": {
     "@capacitor-community/admob": "^8.1.0",
+    "@capacitor-firebase/crashlytics": "^8.5.2",
     "@capacitor-firebase/messaging": "^8.5.2",
     "@capacitor/core": "^8.5.1",
-    "@capacitor/local-notifications": "^8.3.1"
+    "@capacitor/local-notifications": "^8.3.1",
+    "@capawesome/capacitor-app-review": "^8.1.0"
   },
   "peerDependenciesMeta": {
     "@capacitor-community/admob": {
       "optional": true
     },
+    "@capacitor-firebase/crashlytics": {
+      "optional": true
+    },
     "@capacitor-firebase/messaging": {
       "optional": true
     },
     "@capacitor/local-notifications": {
       "optional": true
+    },
+    "@capawesome/capacitor-app-review": {
+      "optional": true
     }
   },
   "devDependencies": {
     "@capacitor-community/admob": "8.1.0",
+    "@capacitor-firebase/crashlytics": "8.5.2",
     "@capacitor-firebase/messaging": "8.5.2",
     "@capacitor/core": "8.5.2",
     "@capacitor/local-notifications": "8.3.1",
+    "@capawesome/capacitor-app-review": "8.1.0",
     "ttsc": "0.32.1",
     "typescript": "7.0.2",
     "vitest": "^4.0.0",
-    "@mpgd/game-runtime": "0.8.4"
+    "@mpgd/game-runtime": "0.8.7"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",