@symbiote-native/notifications 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 A. Prokopenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,258 @@
+# @symbiote-native/notifications
+
+A wrapper package for [SymbioteNative](../../README.md) that makes
+[`expo-notifications`](https://github.com/expo/expo/tree/main/packages/expo-notifications) —
+permissions, device/Expo push tokens, scheduling, presentation, badges, Android channels, iOS/
+Android categories, and the background notification task hook — usable from **every** adapter:
+React, Vue, Svelte, Solid, and Angular. Built the same way as
+[`@symbiote-native/local-auth`](../local-auth): an `expo-modules-core`-based wrapper (see the
+`symbiote-expo-native-module` project skill for the full mechanism — why `expo-modules-core` is
+depended on directly and never the `expo` meta-package, why the upstream JS is hand-ported into
+`core/` rather than imported, and how autolinking picks up the native module).
+
+Every export is a plain async function or a module-level listener registration — no hook/
+composable/service to wrap, so the React, Vue, Svelte, Solid, and Angular entry points are plain
+re-exports of the same `core`.
+
+## Install
+
+**New app:**
+
+```bash
+npx @symbiote-native/cli new my-app --notifications
+```
+
+**Existing SymbioteNative app:**
+
+```bash
+npx @symbiote-native/cli add --notifications
+```
+
+Either way: installs `@symbiote-native/notifications` and wires the native autolinking
+automatically — see [`@symbiote-native/cli`](../cli). Read [past the wiring
+table](#required-one-time-steps-this-linker-does-not-cover--read-before-shipping-push) before
+shipping push, though — the CLI can't automate app-specific native config like a Firebase
+project.
+
+<details>
+<summary>Manual install (no CLI — installing and wiring native autolinking by hand)</summary>
+
+```bash
+npm install @symbiote-native/notifications
+```
+
+`expo-notifications` and `expo-modules-core` come along as regular, pinned dependencies — never
+install either yourself, and never add the `expo` meta-package to your project.
+
+### Required one-time step: native autolinking wiring
+
+Same one-time step as every other `expo-modules-core` package this project ships — see
+[`@symbiote-native/local-auth`'s README](../local-auth/README.md#required-one-time-step-native-autolinking-wiring)
+and the `symbiote-expo-native-module` project skill. The per-package half of that table (the
+Gradle dependency and 13 native-module map entries) is generated by
+[`@symbiote-native/expo-modules-link`](../expo-modules-link) from this package's `native-link.json`
+on every install.
+
+</details>
+
+### Required one-time steps this linker does NOT cover — read before shipping push
+
+Unlike every package this project has wrapped before it, `expo-notifications` needs real,
+app-specific native configuration that a thin JS wrapper cannot supply on its own. Read upstream's
+own config plugin (`plugin/src/withNotifications{Android,IOS}.ts`) before assuming any of this is
+optional — none of it is generated by `@symbiote-native/expo-modules-link`, because none of it fits
+that linker's "fixed value, same for every app" contract (§9 of the `symbiote-expo-native-module`
+skill):
+
+| Platform | What you must add yourself                                                                                                                                                                                                                                                               | Why                                                                                                                                                                                                                                                                                                       |
+| -------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Android  | A real Firebase project + `google-services.json`, plus the Google Services Gradle plugin                                                                                                                                                                                                 | `android/build.gradle` inside `expo-notifications` depends directly on `com.google.firebase:firebase-messaging` — push delivery is FCM, not a generic APNs-style relay, and this is a real exception to "expo-modules-core only" (see the `symbiote-expo-native-module` skill §10d)                       |
+| Android  | A 96×96 all-white PNG copied into `res/drawable-*dpi/notification_icon.png`, plus two `<meta-data>` entries on `<application>`: `com.google.firebase.messaging.default_notification_icon` and `expo.modules.notifications.default_notification_icon`, both `@drawable/notification_icon` | The status-bar icon Android draws for a notification your app did not explicitly build with a custom small icon                                                                                                                                                                                           |
+| Android  | Optionally, `android:color` via `@color/notification_icon_color` and the two matching `default_notification_color` meta-data entries                                                                                                                                                     | Tint applied to the small icon above                                                                                                                                                                                                                                                                      |
+| Android  | Optionally, `com.google.firebase.messaging.default_notification_channel_id` meta-data                                                                                                                                                                                                    | Which channel an FCM-delivered notification lands in when the payload does not name one                                                                                                                                                                                                                   |
+| Android  | Copy any custom sound file into `res/raw/`                                                                                                                                                                                                                                               | `INotificationContentInput.sound` accepts a custom filename on iOS; Android channels carry their own `sound` field instead — see `setNotificationChannelAsync`                                                                                                                                            |
+| iOS      | The **Push Notifications** capability + `aps-environment` entitlement (`development` or `production`) in Xcode                                                                                                                                                                           | `getDevicePushTokenAsync`/`getExpoPushTokenAsync` need APNs registration, which needs this entitlement present — omitting it is a silent registration failure, not a thrown error                                                                                                                         |
+| iOS      | Add any custom sound file as a bundle resource in Xcode                                                                                                                                                                                                                                  | Same as Android's `res/raw/` step, for `INotificationContentInput.sound`                                                                                                                                                                                                                                  |
+| iOS      | Optionally, `UIBackgroundModes` including `remote-notification` in `Info.plist`                                                                                                                                                                                                          | Lets a background/silent push wake the app to run a task registered via `registerTaskAsync`                                                                                                                                                                                                               |
+| Both     | [`@symbiote-native/task-manager`](../task-manager) installed, with a task `defineTask`'d at module scope before `registerTaskAsync` runs                                                                                                                                                 | `registerTaskAsync`/`unregisterTaskAsync` here are thin wrappers over expo-notifications' own `BackgroundNotificationTasksModule`, which upstream itself only works when `expo-task-manager` (this project: `@symbiote-native/task-manager`) is linked — see the `symbiote-expo-native-module` skill §10d |
+
+None of the above is required just to schedule and present **local** notifications — permissions,
+scheduling, presentation, badges, channels, and categories all work with zero app-level native
+config beyond the linker step. Firebase, the icon/color meta-data, and the entitlement are only
+needed once you send a **remote/push** notification.
+
+## Shape
+
+```
+src/core/                 permissions.ts, tokens.ts, presenter.ts, badge.ts, scheduler.ts,
+                          categories.ts, channels.ts, handler.ts, emitter.ts, background-task.ts,
+                          native-modules.ts (13 requireNativeModule() resolutions), utils.ts,
+                          types.ts (I-prefixed, ported from upstream's Notifications.types.ts /
+                          Tokens.types.ts / NotificationChannel(Group)Manager.types.ts /
+                          NotificationScheduler.types.ts)
+src/angular/index.ts      export * from '../core'
+```
+
+`./react`, `./vue`, `./svelte`, and `./solid` are `exports`-map aliases straight onto `src/core/`.
+`./angular` stays a physical file/subpath since Angular ships through a separate `ngc`/AOT build
+(`build-ngc/`).
+
+## Use it
+
+```ts
+import * as Notifications from '@symbiote-native/notifications';
+
+Notifications.setNotificationHandler({
+  handleNotification: async () => ({
+    shouldShowBanner: true,
+    shouldShowList: true,
+    shouldPlaySound: false,
+    shouldSetBadge: false,
+  }),
+});
+
+const { granted } = await Notifications.requestPermissionsAsync();
+if (granted) {
+  const identifier = await Notifications.scheduleNotificationAsync({
+    content: { title: "Time's up!", body: 'Change sides!' },
+    trigger: {
+      type: Notifications.SchedulableTriggerInputTypes.TIME_INTERVAL,
+      seconds: 60,
+    },
+  });
+
+  const subscription = Notifications.addNotificationReceivedListener(
+    notification => {
+      console.log(notification.request.content.title);
+    },
+  );
+  // later: subscription.remove();
+
+  await Notifications.cancelScheduledNotificationAsync(identifier);
+}
+```
+
+Identical import surface on every adapter — `@symbiote-native/notifications/react`, `/vue`,
+`/svelte`, `/solid`, `/angular` all re-export the same functions.
+
+## API
+
+```ts
+// permissions
+getPermissionsAsync(): Promise<INotificationPermissionsStatus>
+requestPermissionsAsync(permissions?: INotificationPermissionsRequest): Promise<INotificationPermissionsStatus>
+
+// tokens
+addPushTokenListener(listener: IPushTokenListener): EventSubscription
+getDevicePushTokenAsync(): Promise<IDevicePushToken>
+getExpoPushTokenAsync(options?: IExpoPushTokenOptions): Promise<IExpoPushToken>
+setAutoServerRegistrationEnabledAsync(enabled: boolean): Promise<void>
+unregisterForNotificationsAsync(): Promise<void>
+subscribeToTopicAsync(topic: string): Promise<null>          // @platform android
+unsubscribeFromTopicAsync(topic: string): Promise<null>      // @platform android
+
+// presentation
+getPresentedNotificationsAsync(): Promise<INotification[]>
+dismissNotificationAsync(notificationIdentifier: string): Promise<void>
+dismissAllNotificationsAsync(): Promise<void>
+
+// badge
+getBadgeCountAsync(): Promise<number>
+setBadgeCountAsync(badgeCount: number): Promise<boolean>
+
+// scheduling
+scheduleNotificationAsync(request: INotificationRequestInput): Promise<string>
+getAllScheduledNotificationsAsync(): Promise<INotificationRequest[]>
+cancelScheduledNotificationAsync(identifier: string): Promise<void>
+cancelAllScheduledNotificationsAsync(): Promise<void>
+getNextTriggerDateAsync(trigger: ISchedulableNotificationTriggerInput): Promise<number | null>
+
+// categories
+getNotificationCategoriesAsync(): Promise<INotificationCategory[]>
+setNotificationCategoryAsync(identifier: string, actions: INotificationAction[], options?: INotificationCategoryOptions): Promise<INotificationCategory>
+deleteNotificationCategoryAsync(identifier: string): Promise<boolean>
+
+// channels — @platform android (no-op returning [] / null / void off Android)
+getNotificationChannelsAsync(): Promise<INotificationChannel[]>
+getNotificationChannelAsync(channelId: string): Promise<INotificationChannel | null>
+setNotificationChannelAsync(channelId: string, channel: INotificationChannelInput): Promise<INotificationChannel | null>
+deleteNotificationChannelAsync(channelId: string): Promise<void>
+getNotificationChannelGroupsAsync(): Promise<INotificationChannelGroup[]>
+getNotificationChannelGroupAsync(groupId: string): Promise<INotificationChannelGroup | null>
+setNotificationChannelGroupAsync(groupId: string, group: INotificationChannelGroupInput): Promise<INotificationChannelGroup | null>
+deleteNotificationChannelGroupAsync(groupId: string): Promise<void>
+
+// handler / emitter
+setNotificationHandler(handler: INotificationHandler | null): void
+addNotificationReceivedListener(listener: (event: INotification) => void): EventSubscription
+addNotificationsDroppedListener(listener: () => void): EventSubscription    // @platform android
+addNotificationResponseReceivedListener(listener: (event: INotificationResponse) => void): EventSubscription
+getLastNotificationResponse(): INotificationResponse | null
+clearLastNotificationResponse(): void
+addNotificationResponseClearedListener(listener: () => void): EventSubscription
+DEFAULT_ACTION_IDENTIFIER: string
+
+// background task (needs @symbiote-native/task-manager, see "Required one-time steps" above)
+registerTaskAsync(taskName: string): Promise<null>
+unregisterTaskAsync(taskName: string): Promise<null>
+```
+
+Plus the enums `IosAlertStyle`, `IosAllowsPreviews`, `IosAuthorizationStatus`,
+`AndroidNotificationVisibility`, `AndroidAudioContentType`, `AndroidImportance`,
+`AndroidAudioUsage`, `AndroidNotificationPriority`, `SchedulableTriggerInputTypes`,
+`BackgroundNotificationTaskResult`, `PermissionStatus` (re-exported from `expo-modules-core`, same
+precedent `@symbiote-native/sensors` uses), and the full `I`-prefixed type surface for content,
+triggers, and native-facing payloads — see `src/core/types.ts`.
+
+## What this port deliberately does not carry over from upstream
+
+- **No automatic push-token server-resync daemon.** Upstream's `DevicePushTokenAutoRegistration.fx.ts`
+  wires a permanent, module-load background listener that re-POSTs a rolled device token to Expo's
+  push backend with exponential retry/backoff (via the `abort-controller` package), whenever
+  registration was left enabled. This port ships `setAutoServerRegistrationEnabledAsync` (used
+  internally by `getExpoPushTokenAsync`) but not the daemon itself — call `getExpoPushTokenAsync()`
+  again from your own `addPushTokenListener` callback for the same effect, without an unconditional
+  background retry loop and its extra dependency.
+- **No `expo-constants`/`expo-application` defaults.** Upstream's `getExpoPushTokenAsync` fills in
+  `projectId` from `Constants.expoConfig.extra.eas.projectId` and `applicationId` from
+  `Application.applicationId` when omitted. Neither package is part of this port (per the
+  `symbiote-expo-native-module` skill, this project depends on `expo-modules-core` only) — pass
+  both explicitly. [`@symbiote-native/application`](../application)'s own `applicationId` export
+  covers the second one.
+- **No `useLastNotificationResponse` React hook.** This package's whole surface is
+  adapter-agnostic plain functions by design — read the last response with
+  `getLastNotificationResponse()` and subscribe to changes with
+  `addNotificationResponseClearedListener`/`addNotificationResponseReceivedListener` directly in
+  whichever lifecycle your framework prefers.
+- **The deprecated `*Async` aliases for `getLastNotificationResponse`/`clearLastNotificationResponse`**
+  are not ported — call the non-`Async` forms upstream itself now recommends.
+- **`SetBadgeCountOptions.web`** (a `badgin` options bag) is web-only; this project targets
+  iOS/Android and `setBadgeCountAsync` takes no options here.
+
+## Notes
+
+- **Android channel/channel-group functions are Android-only, like upstream, but collapsed into
+  one function each.** Upstream splits every one of these into a `.ts` (iOS no-op) and a
+  `.android.ts` (real) file picked by Metro's platform-extension resolution; this port has no
+  separate build step per platform to exploit that split for, so each function branches on
+  `Platform.OS === 'android'` at runtime instead. Off Android they resolve to the same documented
+  no-op values (`[]`/`null`/void) without touching native.
+- **13 native modules autolink from one `expo-notifications` install** —
+  `ExpoNotificationPermissionsModule`, `ExpoPushTokenManager`, `ExpoTopicSubscriptionModule`,
+  `NotificationsServerRegistrationModule`, `ExpoNotificationPresenter`, `ExpoBadgeModule`,
+  `ExpoNotificationScheduler`, `ExpoNotificationCategoriesModule`,
+  `ExpoNotificationChannelManager`, `ExpoNotificationChannelGroupManager`,
+  `ExpoNotificationsHandlerModule`, `ExpoNotificationsEmitter`,
+  `ExpoBackgroundNotificationTasksModule` — see `native-link.json`.
+- **`setNotificationHandler`'s callback must respond within 3 seconds**, matching upstream — a
+  slow `handleNotification` implementation causes native to discard the notification and call
+  `handleError` with a `NotificationTimeoutError` instead.
+
+## Test it
+
+No Fabric/Descriptor angle at all — every function here is a pure async-function surface plus
+event-emitter subscriptions, never a view or per-instance state. Tests inject a fake native-module
+object in place of the real `requireNativeModule` resolution (`vi.mock('./native-modules', …)`)
+and, for the emitter/handler modules, a fake `LegacyEventEmitter` whose listener registry is
+shared across instances so a test can fire an event the same way native would — no `installFabric()`,
+no ViewConfig. See `src/core/*.test.ts`.

package/build/angular/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build/angular/index.js

@@ -0,0 +1 @@
+export * from '../core/index.js';

package/build/core/background-task.d.ts

@@ -0,0 +1,9 @@
+export { BackgroundNotificationTaskResult } from './types';
+/**
+ * Starts delivering notification-received/response events (and, when the app is terminated,
+ * headless background notifications) into a task already defined with
+ * `TaskManager.defineTask(taskName, …)`.
+ */
+export declare function registerTaskAsync(taskName: string): Promise<null>;
+/** Stops delivering into a task registered with `registerTaskAsync`. */
+export declare function unregisterTaskAsync(taskName: string): Promise<null>;

package/build/core/background-task.js

@@ -0,0 +1,28 @@
+// Ported from expo-notifications @ sdk-57's registerTaskAsync.ts / unregisterTaskAsync.ts.
+//
+// Runs on `@symbiote-native/task-manager` under the hood, exactly like upstream runs on
+// `expo-task-manager` — `TaskManager.defineTask(taskName, executor)` must be called first, at
+// the top of the JS bundle (outside any component), then this function tells native to start
+// delivering into that task. See this package's README for the full wiring, including why the
+// task also needs `@symbiote-native/task-manager` installed.
+import { UnavailabilityError } from 'expo-modules-core';
+import { backgroundNotificationTasksModule } from './native-modules.js';
+export { BackgroundNotificationTaskResult } from './types.js';
+/**
+ * Starts delivering notification-received/response events (and, when the app is terminated,
+ * headless background notifications) into a task already defined with
+ * `TaskManager.defineTask(taskName, …)`.
+ */
+export async function registerTaskAsync(taskName) {
+    if (!backgroundNotificationTasksModule.registerTaskAsync) {
+        throw new UnavailabilityError('Notifications', 'registerTaskAsync');
+    }
+    return backgroundNotificationTasksModule.registerTaskAsync(taskName);
+}
+/** Stops delivering into a task registered with `registerTaskAsync`. */
+export async function unregisterTaskAsync(taskName) {
+    if (!backgroundNotificationTasksModule.unregisterTaskAsync) {
+        throw new UnavailabilityError('Notifications', 'unregisterTaskAsync');
+    }
+    return backgroundNotificationTasksModule.unregisterTaskAsync(taskName);
+}

package/build/core/badge.d.ts

@@ -0,0 +1,7 @@
+/** Current app-icon badge count. `0` if unset — not every Android launcher supports badges. */
+export declare function getBadgeCountAsync(): Promise<number>;
+/**
+ * Sets the app-icon badge. `0` clears it. On iOS this needs the `allowBadge` permission
+ * (`requestPermissionsAsync`) or it resolves to `false`.
+ */
+export declare function setBadgeCountAsync(badgeCount: number): Promise<boolean>;

package/build/core/badge.js

@@ -0,0 +1,23 @@
+// Ported from expo-notifications @ sdk-57's getBadgeCountAsync.ts / setBadgeCountAsync.ts.
+//
+// ponytail: upstream's `SetBadgeCountOptions.web` (a `badgin` options bag) is web-only and this
+// project targets iOS/Android — not ported.
+import { UnavailabilityError } from 'expo-modules-core';
+import { badgeModule } from './native-modules.js';
+/** Current app-icon badge count. `0` if unset — not every Android launcher supports badges. */
+export async function getBadgeCountAsync() {
+    if (!badgeModule.getBadgeCountAsync) {
+        throw new UnavailabilityError('Notifications', 'getBadgeCountAsync');
+    }
+    return badgeModule.getBadgeCountAsync();
+}
+/**
+ * Sets the app-icon badge. `0` clears it. On iOS this needs the `allowBadge` permission
+ * (`requestPermissionsAsync`) or it resolves to `false`.
+ */
+export async function setBadgeCountAsync(badgeCount) {
+    if (!badgeModule.setBadgeCountAsync) {
+        throw new UnavailabilityError('Notifications', 'setBadgeCountAsync');
+    }
+    return badgeModule.setBadgeCountAsync(badgeCount);
+}

package/build/core/categories.d.ts

@@ -0,0 +1,10 @@
+import type { INotificationAction, INotificationCategory, INotificationCategoryOptions } from './types';
+/** Every registered notification category. */
+export declare function getNotificationCategoriesAsync(): Promise<INotificationCategory[]>;
+/**
+ * Registers a category of action buttons under `identifier`, referenced later via
+ * `INotificationContentInput.categoryIdentifier`. Avoid `:`/`-` in `identifier`.
+ */
+export declare function setNotificationCategoryAsync(identifier: string, actions: INotificationAction[], options?: INotificationCategoryOptions): Promise<INotificationCategory>;
+/** Deletes a category. Resolves `false` if it did not exist. */
+export declare function deleteNotificationCategoryAsync(identifier: string): Promise<boolean>;

package/build/core/categories.js

@@ -0,0 +1,28 @@
+// Ported from expo-notifications @ sdk-57's getNotificationCategoriesAsync.ts,
+// setNotificationCategoryAsync.ts, deleteNotificationCategoryAsync.ts.
+import { UnavailabilityError } from 'expo-modules-core';
+import { notificationCategoriesModule } from './native-modules.js';
+/** Every registered notification category. */
+export async function getNotificationCategoriesAsync() {
+    if (!notificationCategoriesModule.getNotificationCategoriesAsync) {
+        throw new UnavailabilityError('Notifications', 'getNotificationCategoriesAsync');
+    }
+    return notificationCategoriesModule.getNotificationCategoriesAsync();
+}
+/**
+ * Registers a category of action buttons under `identifier`, referenced later via
+ * `INotificationContentInput.categoryIdentifier`. Avoid `:`/`-` in `identifier`.
+ */
+export async function setNotificationCategoryAsync(identifier, actions, options) {
+    if (!notificationCategoriesModule.setNotificationCategoryAsync) {
+        throw new UnavailabilityError('Notifications', 'setNotificationCategoryAsync');
+    }
+    return notificationCategoriesModule.setNotificationCategoryAsync(identifier, actions, options);
+}
+/** Deletes a category. Resolves `false` if it did not exist. */
+export async function deleteNotificationCategoryAsync(identifier) {
+    if (!notificationCategoriesModule.deleteNotificationCategoryAsync) {
+        throw new UnavailabilityError('Notifications', 'deleteNotificationCategoryAsync');
+    }
+    return notificationCategoriesModule.deleteNotificationCategoryAsync(identifier);
+}

package/build/core/channels.d.ts

@@ -0,0 +1,20 @@
+import { type INotificationChannel, type INotificationChannelGroup, type INotificationChannelGroupInput, type INotificationChannelInput } from './types';
+/** @platform android — empty array on every other platform. */
+export declare function getNotificationChannelsAsync(): Promise<INotificationChannel[]>;
+/** @platform android — `null` on every other platform. */
+export declare function getNotificationChannelAsync(channelId: string): Promise<INotificationChannel | null>;
+/**
+ * Creates or updates a channel. Only the name and description may change once a channel
+ * exists — an Android OS limitation. @platform android — `null` on every other platform.
+ */
+export declare function setNotificationChannelAsync(channelId: string, channel: INotificationChannelInput): Promise<INotificationChannel | null>;
+/** @platform android — no-op on every other platform. */
+export declare function deleteNotificationChannelAsync(channelId: string): Promise<void>;
+/** @platform android — empty array on every other platform. */
+export declare function getNotificationChannelGroupsAsync(): Promise<INotificationChannelGroup[]>;
+/** @platform android — `null` on every other platform. */
+export declare function getNotificationChannelGroupAsync(groupId: string): Promise<INotificationChannelGroup | null>;
+/** @platform android — `null` on every other platform. */
+export declare function setNotificationChannelGroupAsync(groupId: string, group: INotificationChannelGroupInput): Promise<INotificationChannelGroup | null>;
+/** @platform android — no-op on every other platform. */
+export declare function deleteNotificationChannelGroupAsync(groupId: string): Promise<void>;

package/build/core/channels.js

@@ -0,0 +1,106 @@
+// Ported from expo-notifications @ sdk-57's get/set/deleteNotificationChannel(Group)Async.ts —
+// upstream splits each of these into a `.ts` (iOS no-op) and a `.android.ts` (real) file picked
+// by Metro's platform extension resolution; this port collapses each pair into one function with
+// a runtime `Platform.OS === 'android'` branch, since this package has no separate build step
+// per platform to exploit the file-split for.
+import { Platform, UnavailabilityError } from 'expo-modules-core';
+import { notificationChannelGroupManager, notificationChannelManager, } from './native-modules.js';
+import { AndroidImportance, } from './types.js';
+const ANDROID_ONLY_NOTICE = 'Notification channels are only supported on Android.';
+function isAndroid() {
+    return Platform.OS === 'android';
+}
+/** @platform android — empty array on every other platform. */
+export async function getNotificationChannelsAsync() {
+    if (!isAndroid()) {
+        console.debug(ANDROID_ONLY_NOTICE);
+        return [];
+    }
+    if (!notificationChannelManager.getNotificationChannelsAsync) {
+        throw new UnavailabilityError('Notifications', 'getNotificationChannelsAsync');
+    }
+    return ((await notificationChannelManager.getNotificationChannelsAsync()) ?? []);
+}
+/** @platform android — `null` on every other platform. */
+export async function getNotificationChannelAsync(channelId) {
+    if (!isAndroid()) {
+        console.debug(ANDROID_ONLY_NOTICE);
+        return null;
+    }
+    if (!notificationChannelManager.getNotificationChannelAsync) {
+        throw new UnavailabilityError('Notifications', 'getNotificationChannelAsync');
+    }
+    return notificationChannelManager.getNotificationChannelAsync(channelId);
+}
+/**
+ * Creates or updates a channel. Only the name and description may change once a channel
+ * exists — an Android OS limitation. @platform android — `null` on every other platform.
+ */
+export async function setNotificationChannelAsync(channelId, channel) {
+    if (!isAndroid()) {
+        console.debug(ANDROID_ONLY_NOTICE);
+        return null;
+    }
+    if (!notificationChannelManager.setNotificationChannelAsync) {
+        throw new UnavailabilityError('Notifications', 'setNotificationChannelAsync');
+    }
+    if (channel.importance === AndroidImportance.UNSPECIFIED) {
+        console.warn(`[notifications] Channel "${channelId}" importance is UNSPECIFIED, which can error on some Android versions — use AndroidImportance.DEFAULT instead.`);
+    }
+    return notificationChannelManager.setNotificationChannelAsync(channelId, channel);
+}
+/** @platform android — no-op on every other platform. */
+export async function deleteNotificationChannelAsync(channelId) {
+    if (!isAndroid()) {
+        console.debug(ANDROID_ONLY_NOTICE);
+        return;
+    }
+    if (!notificationChannelManager.deleteNotificationChannelAsync) {
+        throw new UnavailabilityError('Notifications', 'deleteNotificationChannelAsync');
+    }
+    return notificationChannelManager.deleteNotificationChannelAsync(channelId);
+}
+/** @platform android — empty array on every other platform. */
+export async function getNotificationChannelGroupsAsync() {
+    if (!isAndroid()) {
+        console.debug(ANDROID_ONLY_NOTICE);
+        return [];
+    }
+    if (!notificationChannelGroupManager.getNotificationChannelGroupsAsync) {
+        throw new UnavailabilityError('Notifications', 'getNotificationChannelGroupsAsync');
+    }
+    return notificationChannelGroupManager.getNotificationChannelGroupsAsync();
+}
+/** @platform android — `null` on every other platform. */
+export async function getNotificationChannelGroupAsync(groupId) {
+    if (!isAndroid()) {
+        console.debug(ANDROID_ONLY_NOTICE);
+        return null;
+    }
+    if (!notificationChannelGroupManager.getNotificationChannelGroupAsync) {
+        throw new UnavailabilityError('Notifications', 'getNotificationChannelGroupAsync');
+    }
+    return notificationChannelGroupManager.getNotificationChannelGroupAsync(groupId);
+}
+/** @platform android — `null` on every other platform. */
+export async function setNotificationChannelGroupAsync(groupId, group) {
+    if (!isAndroid()) {
+        console.debug(ANDROID_ONLY_NOTICE);
+        return null;
+    }
+    if (!notificationChannelGroupManager.setNotificationChannelGroupAsync) {
+        throw new UnavailabilityError('Notifications', 'setNotificationChannelGroupAsync');
+    }
+    return notificationChannelGroupManager.setNotificationChannelGroupAsync(groupId, group);
+}
+/** @platform android — no-op on every other platform. */
+export async function deleteNotificationChannelGroupAsync(groupId) {
+    if (!isAndroid()) {
+        console.debug(ANDROID_ONLY_NOTICE);
+        return;
+    }
+    if (!notificationChannelGroupManager.deleteNotificationChannelGroupAsync) {
+        throw new UnavailabilityError('Notifications', 'deleteNotificationChannelGroupAsync');
+    }
+    return notificationChannelGroupManager.deleteNotificationChannelGroupAsync(groupId);
+}

package/build/core/emitter.d.ts

@@ -0,0 +1,24 @@
+import { type EventSubscription } from 'expo-modules-core';
+import type { INotification, INotificationResponse } from './types';
+export declare const DEFAULT_ACTION_IDENTIFIER = "expo.modules.notifications.actions.DEFAULT";
+/** Fires whenever a notification is received while the app is running. */
+export declare function addNotificationReceivedListener(listener: (event: INotification) => void): EventSubscription;
+/**
+ * Fires whenever the server (Firebase Cloud Messaging) dropped queued notifications.
+ * @platform android
+ */
+export declare function addNotificationsDroppedListener(listener: () => void): EventSubscription;
+/** Fires whenever the user interacts with a notification (e.g. taps it). */
+export declare function addNotificationResponseReceivedListener(listener: (event: INotificationResponse) => void): EventSubscription;
+/**
+ * The most recently received notification response, or `null` if the app was not opened by
+ * one.
+ */
+export declare function getLastNotificationResponse(): INotificationResponse | null;
+/**
+ * Clears the last notification response, e.g. once its route has been handled and should not
+ * be re-applied on the next read.
+ */
+export declare function clearLastNotificationResponse(): void;
+/** Fires whenever `clearLastNotificationResponse` runs. */
+export declare function addNotificationResponseClearedListener(listener: () => void): EventSubscription;

package/build/core/emitter.js

@@ -0,0 +1,58 @@
+// Ported from expo-notifications @ sdk-57's NotificationsEmitter.ts.
+import { LegacyEventEmitter, UnavailabilityError, } from 'expo-modules-core';
+import { dlog } from '@symbiote-native/engine';
+import { notificationsEmitterModule } from './native-modules.js';
+import { mapNotification, mapNotificationResponse } from './utils.js';
+const emitter = new LegacyEventEmitter(notificationsEmitterModule);
+const RECEIVED_EVENT = 'onDidReceiveNotification';
+const DROPPED_EVENT = 'onNotificationsDeleted';
+const RESPONSE_RECEIVED_EVENT = 'onDidReceiveNotificationResponse';
+const RESPONSE_CLEARED_EVENT = 'onDidClearNotificationResponse';
+export const DEFAULT_ACTION_IDENTIFIER = 'expo.modules.notifications.actions.DEFAULT';
+/** Fires whenever a notification is received while the app is running. */
+export function addNotificationReceivedListener(listener) {
+    return emitter.addListener(RECEIVED_EVENT, notification => {
+        dlog(() => `[notifications] received ${notification.request.identifier}`);
+        listener(mapNotification(notification));
+    });
+}
+/**
+ * Fires whenever the server (Firebase Cloud Messaging) dropped queued notifications.
+ * @platform android
+ */
+export function addNotificationsDroppedListener(listener) {
+    return emitter.addListener(DROPPED_EVENT, listener);
+}
+/** Fires whenever the user interacts with a notification (e.g. taps it). */
+export function addNotificationResponseReceivedListener(listener) {
+    return emitter.addListener(RESPONSE_RECEIVED_EVENT, response => {
+        dlog(() => `[notifications] response ${response.actionIdentifier} for ${response.notification.request.identifier}`);
+        listener(mapNotificationResponse(response));
+    });
+}
+/**
+ * The most recently received notification response, or `null` if the app was not opened by
+ * one.
+ */
+export function getLastNotificationResponse() {
+    if (!notificationsEmitterModule.getLastNotificationResponse) {
+        throw new UnavailabilityError('Notifications', 'getLastNotificationResponse');
+    }
+    const response = notificationsEmitterModule.getLastNotificationResponse();
+    return response ? mapNotificationResponse(response) : response;
+}
+/**
+ * Clears the last notification response, e.g. once its route has been handled and should not
+ * be re-applied on the next read.
+ */
+export function clearLastNotificationResponse() {
+    if (!notificationsEmitterModule.clearLastNotificationResponse) {
+        throw new UnavailabilityError('Notifications', 'clearLastNotificationResponse');
+    }
+    notificationsEmitterModule.clearLastNotificationResponse();
+    emitter.emit(RESPONSE_CLEARED_EVENT, []);
+}
+/** Fires whenever `clearLastNotificationResponse` runs. */
+export function addNotificationResponseClearedListener(listener) {
+    return emitter.addListener(RESPONSE_CLEARED_EVENT, listener);
+}

package/build/core/handler.d.ts

@@ -0,0 +1,15 @@
+import { CodedError } from 'expo-modules-core';
+import type { INotification, INotificationHandler } from './types';
+export declare class NotificationTimeoutError extends CodedError {
+    info: {
+        notification: INotification;
+        id: string;
+    };
+    constructor(notificationId: string, notification: INotification);
+}
+/**
+ * Sets the callback deciding whether/how a notification received while the app is running
+ * should be shown. Must respond within 3 seconds or the notification is discarded. Passing
+ * `null` clears the handler — the default (no handler) is to not show anything.
+ */
+export declare function setNotificationHandler(handler: INotificationHandler | null): void;