@mpgd/adapter-capacitor 0.10.1 → 0.11.0

package/dist/notifications-sdk.d.ts

@@ -0,0 +1,166 @@
+import { type PermissionState, type PluginListenerHandle } from '@capacitor/core';
+/** A notification as `@capacitor-firebase/messaging` reports it. */
+export interface PushSdkNotification {
+  readonly id?: string;
+  readonly title?: string;
+  readonly body?: string;
+  /** The FCM data payload (Android) or the APNs `userInfo` (iOS). Untrusted. */
+  readonly data?: unknown;
+}
+export interface PushSdkActionEvent {
+  /** `tap` for the notification itself, otherwise the action's id. */
+  readonly actionId: string;
+  readonly notification: PushSdkNotification;
+}
+/** An Android notification channel, as both plugins create it. */
+export interface NotificationSdkChannel {
+  readonly id: string;
+  readonly name: string;
+  readonly description?: string;
+  /** Android importance, 1 (min) to 5 (max). */
+  readonly importance?: 1 | 2 | 3 | 4 | 5;
+}
+/**
+* Remote notifications through Firebase Cloud Messaging
+* (`@capacitor-firebase/messaging`). iOS registers through Firebase Messaging
+* too, and FCM relays to APNs. Do not install `@capacitor/push-notifications`
+* next to it: on iOS both claim Capacitor's one push handler.
+*/
+export interface PushSdk {
+  /** On Android 12 and lower the plugin answers `granted` whatever the system setting is. */
+  checkPermissions(): Promise<{
+    readonly receive: PermissionState;
+  }>;
+  /** Shows the OS dialog when the OS still allows it; on iOS it also registers with APNs. */
+  requestPermissions(): Promise<{
+    readonly receive: PermissionState;
+  }>;
+  /** Rejects while Firebase cannot issue a token yet (iOS before APNs registration, offline). */
+  getToken(): Promise<{
+    readonly token: string;
+  }>;
+  createChannel?(channel: NotificationSdkChannel): Promise<void>;
+  addListener(eventName: 'tokenReceived', listener: (event: {
+    readonly token: string;
+  }) => void): Promise<PluginListenerHandle>;
+  addListener(eventName: 'notificationReceived', listener: (event: {
+    readonly notification: PushSdkNotification;
+  }) => void): Promise<PluginListenerHandle>;
+  addListener(eventName: 'notificationActionPerformed', listener: (event: PushSdkActionEvent) => void): Promise<PluginListenerHandle>;
+}
+/** A scheduled local notification as the provider writes it. */
+export interface LocalNotificationSdkSchema {
+  readonly id: number;
+  readonly title: string;
+  readonly body: string;
+  /** `allowWhileIdle` lets an inexact alarm fire in Doze (`setAndAllowWhileIdle`). */
+  readonly schedule: {
+    readonly at: Date;
+    readonly allowWhileIdle: true;
+  };
+  /** Round-trips through `getPending` and the listeners; the provider stores its key there. */
+  readonly extra: Readonly<Record<string, string>>;
+  /** Android only. */
+  readonly channelId?: string;
+  /**
+  * Always `false`: the plugin defaults to exact alarms, which on Android 12+
+  * opens the "Alarms & reminders" screen when the app lacks
+  * `SCHEDULE_EXACT_ALARM`, and Android 14 denies that permission by default.
+  */
+  readonly isExactNotification: false;
+}
+/** A local notification as `getPending` and the listeners report it. */
+export interface LocalNotificationSdkEntry {
+  readonly id: number;
+  /** `getPending` reports these; the provider restores an evicted reminder from them. */
+  readonly title?: string;
+  readonly body?: string;
+  readonly extra?: unknown;
+}
+export interface LocalNotificationSdkActionType {
+  readonly id: string;
+  readonly actions: {
+    readonly id: string;
+    readonly title: string;
+    /** Opens the app, so the game can route the action. */
+    readonly foreground?: boolean;
+  }[];
+}
+/**
+* Device-scheduled notifications (`@capacitor/local-notifications`). Its
+* `schedule` asks for the notification permission by itself on Android 13+,
+* so the provider calls it only once a fresh `checkPermissions` answered
+* `granted` (RFC "Consent model": never prompt as a side effect).
+*/
+export interface LocalNotificationSdk {
+  /** Reflects the system setting on every Android version, unlike the push plugin. */
+  checkPermissions(): Promise<{
+    readonly display: PermissionState;
+  }>;
+  requestPermissions(): Promise<{
+    readonly display: PermissionState;
+  }>;
+  schedule(options: {
+    readonly notifications: LocalNotificationSdkSchema[];
+  }): Promise<unknown>;
+  cancel(options: {
+    readonly notifications: {
+      readonly id: number;
+    }[];
+  }): Promise<void>;
+  getPending(): Promise<{
+    readonly notifications: readonly LocalNotificationSdkEntry[];
+  }>;
+  createChannel(channel: NotificationSdkChannel): Promise<void>;
+  /**
+  * On iOS this sets the app's notification categories, which remote
+  * notifications use too, so it also carries the advertising opt-out
+  * category for FCM sends.
+  */
+  registerActionTypes(options: {
+    readonly types: LocalNotificationSdkActionType[];
+  }): Promise<void>;
+  addListener(eventName: 'localNotificationReceived', listener: (notification: LocalNotificationSdkEntry) => void): Promise<PluginListenerHandle>;
+  addListener(eventName: 'localNotificationActionPerformed', listener: (event: {
+    readonly actionId: string;
+    readonly notification: LocalNotificationSdkEntry;
+  }) => void): Promise<PluginListenerHandle>;
+}
+export interface CapacitorNotificationSdks {
+  /** Absent when `@capacitor-firebase/messaging` is not installed in the native shell. */
+  readonly push?: PushSdk;
+  /** Absent when `@capacitor/local-notifications` is not installed in the native shell. */
+  readonly local?: LocalNotificationSdk;
+}
+/** What `loadCapacitorNotificationSdks` asks of the Capacitor runtime. */
+export interface CapacitorNotificationSdkRuntime {
+  isNativePlatform(): boolean;
+  isPluginAvailable(name: string): boolean;
+}
+export interface LoadCapacitorNotificationSdksInput {
+  /** Defaults to `Capacitor` from `@capacitor/core`. */
+  readonly runtime?: CapacitorNotificationSdkRuntime;
+  /** Defaults to `import('@capacitor-firebase/messaging')`. */
+  readonly importPush?: () => Promise<{
+    readonly FirebaseMessaging: unknown;
+  }>;
+  /** Defaults to `import('@capacitor/local-notifications')`. */
+  readonly importLocal?: () => Promise<{
+    readonly LocalNotifications: unknown;
+  }>;
+}
+/** The names the two plugins register with Capacitor. */
+export declare const capacitorNotificationPluginNames: Readonly<{
+  readonly push: 'FirebaseMessaging';
+  readonly local: 'LocalNotifications';
+}>;
+/**
+* Loads the two optional plugins. Each half is absent, so the provider fails
+* closed for it, when the app does not run natively (a browser preview would
+* reach the plugins' web fallbacks), when the shell has no native
+* implementation of the plugin, or when the package cannot be imported. A
+* game that bundles `@mpgd/adapter-capacitor/notifications` installs both
+* peers, so the bundler resolves both imports; the native shell decides which
+* plugin is present.
+*/
+export declare function loadCapacitorNotificationSdks(input?: LoadCapacitorNotificationSdksInput): Promise<CapacitorNotificationSdks>;

package/dist/notifications-sdk.js

@@ -0,0 +1,47 @@
+import { Capacitor } from '@capacitor/core';
+/** The names the two plugins register with Capacitor. */
+export const capacitorNotificationPluginNames = Object.freeze({
+    push: 'FirebaseMessaging',
+    local: 'LocalNotifications',
+});
+/**
+ * Loads the two optional plugins. Each half is absent, so the provider fails
+ * closed for it, when the app does not run natively (a browser preview would
+ * reach the plugins' web fallbacks), when the shell has no native
+ * implementation of the plugin, or when the package cannot be imported. A
+ * game that bundles `@mpgd/adapter-capacitor/notifications` installs both
+ * peers, so the bundler resolves both imports; the native shell decides which
+ * plugin is present.
+ */
+export async function loadCapacitorNotificationSdks(input = {}) {
+    const runtime = input.runtime ?? Capacitor;
+    if (!runtime.isNativePlatform()) {
+        return {};
+    }
+    const [push, local] = await Promise.all([
+        runtime.isPluginAvailable(capacitorNotificationPluginNames.push)
+            ? importPlugin(input.importPush ?? (() => import('@capacitor-firebase/messaging')), 'FirebaseMessaging')
+            : undefined,
+        runtime.isPluginAvailable(capacitorNotificationPluginNames.local)
+            ? importPlugin(input.importLocal ?? (() => import('@capacitor/local-notifications')), 'LocalNotifications')
+            : undefined,
+    ]);
+    return {
+        ...(push === undefined ? {} : { push: push.plugin }),
+        ...(local === undefined ? {} : { local: local.plugin }),
+    };
+}
+/**
+ * Imports one plugin, boxed: a Capacitor plugin is a proxy that answers every
+ * property, `then` included, so resolving a promise with it would call a
+ * native `then` that does not exist. Only the box crosses an `await`.
+ */
+async function importPlugin(load, name) {
+    try {
+        const plugin = (await load())[name];
+        return typeof plugin === 'object' && plugin !== null ? { plugin } : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/notifications.d.ts

@@ -0,0 +1,27 @@
+import { type CreateCapacitorNotificationProviderInput } from './notifications-provider.js';
+import type { CapacitorNotificationServiceProvider } from './providers.js';
+export { capacitorNotificationPluginNames, loadCapacitorNotificationSdks, type CapacitorNotificationSdkRuntime, type CapacitorNotificationSdks, type LoadCapacitorNotificationSdksInput, type LocalNotificationSdk, type LocalNotificationSdkActionType, type LocalNotificationSdkEntry, type LocalNotificationSdkSchema, type NotificationSdkChannel, type PushSdk, type PushSdkActionEvent, type PushSdkNotification, } from './notifications-sdk.js';
+export { capacitorAdvertisingActionTypeId, capacitorIosMaxPendingLocalNotifications, capacitorLocalNotificationId, capacitorNotificationChannelId, capacitorNotificationDataKeys, capacitorNotificationProviderId, capacitorSettingsLeaveTimeoutMs, capacitorSettingsReturnTimeoutMs, createCapacitorNotificationProvider, type CapacitorNotificationAppEvents, type CapacitorNotificationChannelSettings, type CapacitorNotificationProvider, type CreateCapacitorNotificationProviderInput, } from './notifications-provider.js';
+export { createBridgeNotificationProvider, createNotificationProviderBridge, createNotificationServiceProvider, createNotificationSubscriptionAdapter, type CreateBridgeNotificationProviderInput, type CreateNotificationProviderBridgeInput, type CreateNotificationServiceProviderInput, type NotificationProviderBridge, } from './notifications-bridge.js';
+export type { CapacitorNotificationServiceProvider, CapacitorNotificationsV2Service, } from './providers.js';
+export interface CreateCapacitorNotificationServiceProviderInput extends CreateCapacitorNotificationProviderInput {
+  /** The registry id; 'capacitor-notifications' when absent. */
+  readonly id?: string;
+}
+/**
+* The provider and its registry entry in one call, with the same topics, for
+* `createCapacitorPlatformGateway({ providers: [...] })`:
+*
+* ```ts
+* const sdks = await loadCapacitorNotificationSdks();
+* const notifications = createCapacitorNotificationServiceProvider({
+*   platform: 'android',
+*   topics: resolveNotificationTopicsForTarget(catalog, 'android'),
+*   ...sdks,
+* });
+* ```
+*
+* Create it once, early in startup: the provider registers its native
+* listeners when it is created, which is when a cold-start open reaches it.
+*/
+export declare function createCapacitorNotificationServiceProvider(input: CreateCapacitorNotificationServiceProviderInput): CapacitorNotificationServiceProvider;

package/dist/notifications.js

@@ -0,0 +1,35 @@
+import { createNotificationServiceProvider } from './notifications-bridge.js';
+import { createCapacitorNotificationProvider, } from './notifications-provider.js';
+// `@mpgd/adapter-capacitor/notifications`: the notifications v2 provider for
+// Android and iOS (notifications RFC "Provider profiles", Capacitor). Only
+// this subpath loads the notifications validators and, dynamically, the
+// optional `@capacitor-firebase/messaging` and `@capacitor/local-notifications`
+// peers; the base adapter entry loads neither.
+export { capacitorNotificationPluginNames, loadCapacitorNotificationSdks, } from './notifications-sdk.js';
+export { capacitorAdvertisingActionTypeId, capacitorIosMaxPendingLocalNotifications, capacitorLocalNotificationId, capacitorNotificationChannelId, capacitorNotificationDataKeys, capacitorNotificationProviderId, capacitorSettingsLeaveTimeoutMs, capacitorSettingsReturnTimeoutMs, createCapacitorNotificationProvider, } from './notifications-provider.js';
+export { createBridgeNotificationProvider, createNotificationProviderBridge, createNotificationServiceProvider, createNotificationSubscriptionAdapter, } from './notifications-bridge.js';
+/**
+ * The provider and its registry entry in one call, with the same topics, for
+ * `createCapacitorPlatformGateway({ providers: [...] })`:
+ *
+ * ```ts
+ * const sdks = await loadCapacitorNotificationSdks();
+ * const notifications = createCapacitorNotificationServiceProvider({
+ *   platform: 'android',
+ *   topics: resolveNotificationTopicsForTarget(catalog, 'android'),
+ *   ...sdks,
+ * });
+ * ```
+ *
+ * Create it once, early in startup: the provider registers its native
+ * listeners when it is created, which is when a cold-start open reaches it.
+ */
+export function createCapacitorNotificationServiceProvider(input) {
+    const { id, ...providerInput } = input;
+    const notifications = createCapacitorNotificationProvider(providerInput);
+    return createNotificationServiceProvider({
+        id: id ?? 'capacitor-notifications',
+        notifications,
+        topics: notifications.topics,
+    });
+}

package/dist/providers.d.ts

@@ -1,7 +1,8 @@
-import { type BridgeEvent, type BridgeMethod, type BridgeRequest, type BridgeResponse } from '@mpgd/bridge';
+import { type BridgeEvent, type BridgeMethod, type BridgeNotificationsEvent, type BridgeNotificationsV2Method, type BridgeRequest, type BridgeResponse } from '@mpgd/bridge';
 import type { AdProvider } from '@mpgd/platform/ads';
-import { type CommerceCapabilities, type PlatformProviderAvailability, type PlatformProviderFeature } from '@mpgd/platform';
+import { type CommerceCapabilities, type NotificationSubscriptionAdapter, type PlatformProviderAvailability, type PlatformProviderFeature } from '@mpgd/platform';
 import { type CommerceProvider } from '@mpgd/platform/commerce';
+import type { NotificationCapabilities, NotificationProvider } from '@mpgd/platform/notifications';
 export interface NativeBridge {
   request(input: BridgeRequest): Promise<BridgeResponse>;
   /**
@@ -45,8 +46,43 @@ export interface CapacitorServiceProvider {
   * covers the declared `features`.
   */
   readonly commerce?: CommerceProvider;
+  /**
+  * Optional notifications v2 service (`createNotificationServiceProvider`
+  * from `@mpgd/adapter-capacitor/notifications`). The nine
+  * `notifications.v2.*` methods are implied, and the gateway serves both
+  * `notificationsV2` and the v1 `notifications` adapter from it.
+  */
+  readonly notificationsV2?: CapacitorNotificationsV2Service;
   getAvailability(): Promise<Readonly<Partial<Record<PlatformProviderFeature, PlatformProviderAvailability>>>>;
 }
+/**
+* What the gateway needs from a notifications v2 service. It comes from
+* `@mpgd/adapter-capacitor/notifications`, which holds the validators, so the
+* base adapter loads none of them.
+*/
+export interface CapacitorNotificationsV2Service {
+  /** The service's own capability block, validated and copied. */
+  getCapabilities(): Promise<NotificationCapabilities>;
+  /** Throws when `data` is not a valid answer to `method`. */
+  assertResult(method: BridgeNotificationsV2Method, data: unknown): void;
+  /**
+  * The game-facing surfaces over the gateway's request path: the
+  * `notificationsV2` provider, and the v1 adapter served from it (RFC
+  * "Capabilities": an adapter that exposes both backs v1 with v2).
+  */
+  createGatewaySurface(input: {
+    readonly request: <TData>(method: BridgeNotificationsV2Method, payload: unknown) => Promise<TData>;
+    readonly subscribe: (listener: (event: BridgeNotificationsEvent) => void) => () => void;
+  }): {
+    readonly notificationsV2: NotificationProvider;
+    readonly notifications: NotificationSubscriptionAdapter;
+  };
+}
+/** The provider the registry serves notifications v2 from. */
+export interface CapacitorNotificationServiceProvider extends CapacitorServiceProvider {
+  readonly notificationsV2: CapacitorNotificationsV2Service;
+  readonly bridge: NativeBridge & Required<Pick<NativeBridge, 'subscribe'>>;
+}
 /** The provider the registry serves commerce v2 from. */
 export interface CapacitorCommerceServiceProvider extends CapacitorServiceProvider {
   readonly commerce: CommerceProvider;
@@ -63,17 +99,34 @@ export interface CapacitorProviderCapabilitySnapshot {
   * registered.
   */
   readonly commerce: CommerceCapabilities;
+  /**
+  * Present exactly when a notifications v2 service is registered: its
+  * validated block, or the degraded block (`availability:
+  * 'temporarily-unavailable'`, nothing offered) when that bounded read
+  * stalled or failed. `availability.pushNotifications` equals its
+  * `availability`.
+  */
+  readonly notifications?: NotificationCapabilities;
 }
 export interface CapacitorProviderRegistry {
   readonly byMethod: ReadonlyMap<BridgeMethod, CapacitorServiceProvider>;
   /** The provider that serves commerce v2, when one is registered. */
   readonly commerce?: CapacitorCommerceServiceProvider;
+  /** The provider that serves notifications v2, when one is registered. */
+  readonly notifications?: CapacitorNotificationServiceProvider;
   /** Feature readiness plus the commerce block, from one bounded read per provider. */
   getCapabilitySnapshot(): Promise<CapacitorProviderCapabilitySnapshot>;
   assertMethodReady(method: BridgeMethod, payload?: unknown): Promise<void>;
   getAvailability(): Promise<Readonly<Record<PlatformProviderFeature, PlatformProviderAvailability>>>;
 }
 export declare function createCapacitorProviderRegistry(input: readonly CapacitorServiceProvider[]): CapacitorProviderRegistry;
-export declare function assertProviderResponseData(method: BridgeMethod, data: unknown): void;
+export declare function assertProviderResponseData(method: BridgeMethod, data: unknown, provider?: CapacitorServiceProvider): void;
+/**
+* The notifications block a gateway reports while its service cannot be
+* read: nothing offered, `availability: 'temporarily-unavailable'`. The same
+* fields as `createUnsupportedNotificationCapabilities()`, written out so the
+* base adapter loads no notifications module.
+*/
+export declare function createDegradedNotificationCapabilities(): NotificationCapabilities;
 /** The commerce block a gateway reports while its provider cannot be read. */
 export declare function createDegradedCommerceCapabilities(): CommerceCapabilities;

package/dist/providers.js

@@ -1,4 +1,4 @@
-import { bridgeCommerceV2Methods, isBridgeCommerceV2Method, isBridgeNotificationsV2Method, } from '@mpgd/bridge';
+import { bridgeCommerceV2Methods, bridgeNotificationsV2Methods, isBridgeCommerceV2Method, isBridgeNotificationsV2Method, } from '@mpgd/bridge';
 import { isAdMobClientRewardEvidence } from '@mpgd/game-services/admob-client-reward';
 import { PlatformOperationError, } from '@mpgd/platform';
 import { createUnsupportedCommerceCapabilities, isCommerceCapabilities, } from '@mpgd/platform/commerce';
@@ -14,6 +14,7 @@ const featureMethods = {
 const providerFeatures = Object.keys(featureMethods);
 const providerMethodSet = new Set(Object.values(featureMethods).flat());
 const impliedCommerceMethods = bridgeCommerceV2Methods;
+const impliedNotificationMethods = bridgeNotificationsV2Methods;
 const availabilitySet = new Set([
     'unsupported',
     'configuration-required',
@@ -33,12 +34,13 @@ export function createCapacitorProviderRegistry(input) {
     const byFeature = new Map();
     const ids = new Set();
     let commerce;
+    let notifications;
     for (const provider of providers) {
         if (provider.id.trim() === '' || ids.has(provider.id)) {
             throw new Error(`Capacitor provider ID is empty or registered twice: ${provider.id}`);
         }
         ids.add(provider.id);
-        if (provider.commerce === undefined
+        if (provider.commerce === undefined && provider.notificationsV2 === undefined
             && (provider.features.length === 0 || provider.methods.length === 0)) {
             throw new Error(`Capacitor provider ${provider.id} must declare features and methods.`);
         }
@@ -54,16 +56,20 @@ export function createCapacitorProviderRegistry(input) {
                     + 'unavailable as a declared method.');
             }
             if (isBridgeNotificationsV2Method(method)) {
-                // A notifications v2 provider gets its own registry surface (P2); a
-                // declared method would bypass the pass-through readiness rule.
-                throw new Error(`Capacitor provider ${provider.id} cannot declare notifications v2 method ${method}; `
-                    + 'notifications v2 is unavailable as a declared method.');
+                // A notifications v2 provider is registered through `notificationsV2`;
+                // a declared method would bypass the pass-through readiness rule.
+                throw new Error(`Capacitor provider ${provider.id} cannot declare notifications v2 method ${method}: `
+                    + 'notifications v2 is unavailable as a declared method. Register a notifications '
+                    + 'service through `notificationsV2` instead.');
             }
             if (!providerMethodSet.has(method)) {
                 throw new Error(`Capacitor provider ${provider.id} cannot replace base method ${method}.`);
             }
         }
-        const implied = provider.commerce === undefined ? [] : impliedCommerceMethods;
+        const implied = [
+            ...(provider.commerce === undefined ? [] : impliedCommerceMethods),
+            ...(provider.notificationsV2 === undefined ? [] : impliedNotificationMethods),
+        ];
         for (const method of [...methods, ...implied]) {
             if (byMethod.has(method)) {
                 throw new Error(`Capacitor bridge method ${method} has multiple providers.`);
@@ -76,6 +82,11 @@ export function createCapacitorProviderRegistry(input) {
             throw new Error(`Capacitor provider ${provider.id} declares a commerce provider but its bridge has no `
                 + 'subscribe; build it with createCommerceServiceProvider.');
         }
+        if (provider.notificationsV2 !== undefined && provider.bridge.subscribe === undefined) {
+            // Opens and endpoint changes arrive only as events.
+            throw new Error(`Capacitor provider ${provider.id} declares a notifications service but its bridge has `
+                + 'no subscribe; build it with createNotificationServiceProvider.');
+        }
         for (const feature of provider.features) {
             const required = featureMethods[feature];
             if (required === undefined || byFeature.has(feature)) {
@@ -96,6 +107,16 @@ export function createCapacitorProviderRegistry(input) {
             // Validated above: the bridge implements `subscribe`.
             commerce = provider;
         }
+        if (provider.notificationsV2 !== undefined) {
+            // Validated above: the bridge implements `subscribe`.
+            notifications = provider;
+        }
+    }
+    if (notifications !== undefined && byFeature.has('pushNotifications')) {
+        // The v1 adapter is served from the v2 provider, so the two report the
+        // same readiness (RFC "Capabilities").
+        throw new Error(`Capacitor provider ${byFeature.get('pushNotifications')?.id} declares pushNotifications, `
+            + `which the notifications v2 provider ${notifications.id} serves.`);
     }
     const readFeatureStates = async (provider) => {
         const states = {};
@@ -112,13 +133,20 @@ export function createCapacitorProviderRegistry(input) {
         return states;
     };
     const readProviderStates = async (provider) => {
-        const [states, commerceBlock] = await Promise.all([
+        const [states, commerceBlock, notificationsBlock] = await Promise.all([
             readFeatureStates(provider),
             provider.commerce === undefined
                 ? Promise.resolve(undefined)
                 : readCommerceCapabilities(provider.commerce),
+            provider.notificationsV2 === undefined
+                ? Promise.resolve(undefined)
+                : readNotificationCapabilities(provider.notificationsV2),
         ]);
-        return { states, ...(commerceBlock === undefined ? {} : { commerce: commerceBlock }) };
+        return {
+            states,
+            ...(commerceBlock === undefined ? {} : { commerce: commerceBlock }),
+            ...(notificationsBlock === undefined ? {} : { notifications: notificationsBlock }),
+        };
     };
     const getCapabilitySnapshot = async () => {
         const states = {};
@@ -126,10 +154,12 @@ export function createCapacitorProviderRegistry(input) {
             states[feature] = 'unsupported';
         }
         let commerceBlock;
+        let notificationsBlock;
         const snapshots = await Promise.all(providers.map(readProviderStates));
         for (const snapshot of snapshots) {
             Object.assign(states, snapshot.states);
             commerceBlock = snapshot.commerce ?? commerceBlock;
+            notificationsBlock = snapshot.notifications ?? notificationsBlock;
         }
         if (commerce === undefined) {
             commerceBlock = createUnsupportedCommerceCapabilities();
@@ -139,12 +169,19 @@ export function createCapacitorProviderRegistry(input) {
             // provider degrades it without rejecting the snapshot.
             commerceBlock = createDegradedCommerceCapabilities();
         }
-        return { availability: states, commerce: commerceBlock };
+        if (notifications === undefined) {
+            return { availability: states, commerce: commerceBlock };
+        }
+        notificationsBlock ??= createDegradedNotificationCapabilities();
+        // The v1 readiness follows the v2 block it is served from.
+        states.pushNotifications = notificationsBlock.availability;
+        return { availability: states, commerce: commerceBlock, notifications: notificationsBlock };
     };
     const getAvailability = async () => (await getCapabilitySnapshot()).availability;
     return {
         byMethod,
         ...(commerce === undefined ? {} : { commerce }),
+        ...(notifications === undefined ? {} : { notifications }),
         getAvailability,
         getCapabilitySnapshot,
         async assertMethodReady(method, payload) {
@@ -212,11 +249,15 @@ export function createCapacitorProviderRegistry(input) {
         },
     };
 }
-export function assertProviderResponseData(method, data) {
-    const valid = isValidProviderData(method, data);
+export function assertProviderResponseData(method, data, provider) {
+    const valid = isValidProviderData(method, data, provider);
     if (!valid) {
         throw new PlatformOperationError({
-            code: 'NATIVE_PROVIDER_INVALID_RESPONSE',
+            // A notifications v2 answer that breaks the contract is the provider's
+            // configuration error (RFC "Bridge and versioning"), as on Apps in Toss.
+            code: isBridgeNotificationsV2Method(method)
+                ? 'NOTIFICATIONS_CONFIGURATION_REQUIRED'
+                : 'NATIVE_PROVIDER_INVALID_RESPONSE',
             message: `Capacitor provider returned invalid data for ${method}.`,
         });
     }
@@ -239,6 +280,36 @@ async function readCommerceCapabilities(provider) {
         availability: reported.availability,
     };
 }
+/**
+ * One bounded notifications capability read. The service validates and copies
+ * its own block; a stalled or throwing read yields `undefined`.
+ */
+async function readNotificationCapabilities(service) {
+    return readWithTimeout(Promise.resolve().then(() => service.getCapabilities()));
+}
+/**
+ * The notifications block a gateway reports while its service cannot be
+ * read: nothing offered, `availability: 'temporarily-unavailable'`. The same
+ * fields as `createUnsupportedNotificationCapabilities()`, written out so the
+ * base adapter loads no notifications module.
+ */
+export function createDegradedNotificationCapabilities() {
+    return {
+        availability: 'temporarily-unavailable',
+        permission: {
+            scope: 'app',
+            prompt: 'os',
+            readable: true,
+            serverReadable: false,
+            allowance: 'persistent',
+            userGesture: false,
+            settings: false,
+        },
+        remote: { supported: false, purposes: [], addressing: 'none', content: 'free-form' },
+        local: { supported: false },
+        open: 'none',
+    };
+}
 /** The commerce block a gateway reports while its provider cannot be read. */
 export function createDegradedCommerceCapabilities() {
     return { ...createUnsupportedCommerceCapabilities(), availability: 'temporarily-unavailable' };
@@ -271,7 +342,7 @@ function isString(value) {
 function isVoidData(value) {
     return value === undefined || value === null || (isRecord(value) && Object.keys(value).length === 0);
 }
-function isValidProviderData(method, value) {
+function isValidProviderData(method, value, provider) {
     if (isBridgeCommerceV2Method(method)) {
         try {
             assertCommerceBridgeResult(method, value);
@@ -282,10 +353,19 @@ function isValidProviderData(method, value) {
         }
     }
     if (isBridgeNotificationsV2Method(method)) {
-        // P2 must validate these answers here, with `assertBridgeNotificationsV2Result`
-        // from `@mpgd/bridge/notifications`, when it lets a provider serve the
-        // methods. Until then every notifications v2 answer is rejected.
-        return false;
+        // The service validates with `assertBridgeNotificationsV2Result` from
+        // `@mpgd/bridge/notifications`; a provider without one serves no v2
+        // method, so its answer is rejected.
+        if (provider?.notificationsV2 === undefined) {
+            return false;
+        }
+        try {
+            provider.notificationsV2.assertResult(method, value);
+            return true;
+        }
+        catch {
+            return false;
+        }
     }
     switch (method) {
         case 'ads.preload':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mpgd/adapter-capacitor",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "Capacitor platform adapter for mpgd Android and iOS shells.",
   "license": "MIT",
   "repository": {
@@ -32,6 +32,10 @@
     "./admob": {
       "types": "./dist/admob.d.ts",
       "default": "./dist/admob.js"
+    },
+    "./notifications": {
+      "types": "./dist/notifications.d.ts",
+      "default": "./dist/notifications.js"
     }
   },
   "files": [
@@ -39,28 +43,38 @@
   ],
   "dependencies": {
     "@capacitor/app": "8.1.1",
-    "@mpgd/bridge": "0.13.1",
-    "@mpgd/capacitor-game-services": "0.7.1",
-    "@mpgd/game-services": "0.24.1",
-    "@mpgd/platform": "0.23.1",
-    "@mpgd/target-config": "0.23.1"
+    "@mpgd/bridge": "0.13.2",
+    "@mpgd/game-services": "0.25.0",
+    "@mpgd/capacitor-game-services": "0.7.2",
+    "@mpgd/platform": "0.24.0",
+    "@mpgd/target-config": "0.23.2"
   },
   "peerDependencies": {
     "@capacitor-community/admob": "^8.1.0",
-    "@capacitor/core": "^8.5.1"
+    "@capacitor-firebase/messaging": "^8.5.2",
+    "@capacitor/core": "^8.5.1",
+    "@capacitor/local-notifications": "^8.3.1"
   },
   "peerDependenciesMeta": {
     "@capacitor-community/admob": {
       "optional": true
+    },
+    "@capacitor-firebase/messaging": {
+      "optional": true
+    },
+    "@capacitor/local-notifications": {
+      "optional": true
     }
   },
   "devDependencies": {
     "@capacitor-community/admob": "8.1.0",
+    "@capacitor-firebase/messaging": "8.5.2",
     "@capacitor/core": "8.5.2",
+    "@capacitor/local-notifications": "8.3.1",
     "ttsc": "0.32.1",
     "typescript": "7.0.2",
     "vitest": "^4.0.0",
-    "@mpgd/game-runtime": "0.7.1"
+    "@mpgd/game-runtime": "0.7.2"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",