@fishonfire/bubbles-expo 0.1.0

package/dist/index.js

@@ -0,0 +1,2060 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ANDROID_CHANNEL_IMPORTANCE_VALUES: () => ANDROID_CHANNEL_IMPORTANCE_VALUES2,
+  BUBBLES_DELIVERY_STATUSES: () => BUBBLES_DELIVERY_STATUSES,
+  BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY: () => BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY2,
+  BubblesAppAuthenticationError: () => BubblesAppAuthenticationError,
+  BubblesNotificationsProvider: () => BubblesNotificationsProvider,
+  buildBubblesDeliveryStatusPayload: () => buildBubblesDeliveryStatusPayload,
+  buildCreateDevicePayload: () => buildCreateDevicePayload,
+  buildStoredDeliveryStatusEventKey: () => buildStoredDeliveryStatusEventKey,
+  buildUpdateDevicePayload: () => buildUpdateDevicePayload,
+  createBubblesDevice: () => createBubblesDevice,
+  createBubblesDeviceClient: () => createBubblesDeviceClient,
+  createStoredDeliveryStatusEvent: () => createStoredDeliveryStatusEvent,
+  describeNotificationPermissionStatus: () => describeNotificationPermissionStatus,
+  enqueueStoredDeliveryStatusEvent: () => enqueueStoredDeliveryStatusEvent,
+  ensureDefaultNotificationChannel: () => ensureDefaultNotificationChannel,
+  ensureNotificationPermissions: () => ensureNotificationPermissions,
+  extractDeviceIdFromDeviceResponse: () => extractDeviceIdFromDeviceResponse,
+  flushStoredBubblesDeliveryStatuses: () => flushStoredBubblesDeliveryStatuses,
+  getAndroidNotificationChannelImportance: () => getAndroidNotificationChannelImportance,
+  getBubblesNotificationsRuntimeConfig: () => getBubblesNotificationsRuntimeConfig,
+  getDefaultNotificationChannelConfig: () => getDefaultNotificationChannelConfig,
+  getDeviceRegistrationState: () => getDeviceRegistrationState,
+  getDeviceToken: () => getDeviceToken,
+  getFCMToken: () => getFCMToken,
+  getNotificationPermissions: () => getNotificationPermissions,
+  isNotificationPermissionGranted: () => isNotificationPermissionGranted,
+  markStoredDeliveryStatusEventPosted: () => markStoredDeliveryStatusEventPosted,
+  patchStoredDeviceState: () => patchStoredDeviceState,
+  postBubblesDeliveryStatus: () => postBubblesDeliveryStatus,
+  postStoredBubblesDeliveryStatus: () => postStoredBubblesDeliveryStatus,
+  readStoredApiBaseUrl: () => readStoredApiBaseUrl,
+  readStoredAppKey: () => readStoredAppKey,
+  readStoredDeliveryStatusLedger: () => readStoredDeliveryStatusLedger,
+  readStoredDeviceId: () => readStoredDeviceId,
+  readStoredDeviceState: () => readStoredDeviceState,
+  registerBubblesBackgroundHandlers: () => registerBubblesBackgroundHandlers,
+  storeApiBaseUrl: () => storeApiBaseUrl,
+  storeAppKey: () => storeAppKey,
+  storeDeliveryStatusLedger: () => storeDeliveryStatusLedger,
+  storeDeviceId: () => storeDeviceId,
+  storeDeviceState: () => storeDeviceState,
+  syncBubblesDevice: () => syncBubblesDevice,
+  updateBubblesDevice: () => updateBubblesDevice,
+  useBubblesNotifications: () => useBubblesNotifications
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config/runtime-config.ts
+var import_expo_constants = __toESM(require("expo-constants"));
+
+// plugin/src/shared-config.ts
+var BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY = "bubblesNotificationsExpo";
+var ANDROID_CHANNEL_IMPORTANCE_VALUES = [
+  "min",
+  "low",
+  "default",
+  "high",
+  "max"
+];
+
+// src/internal/errors.ts
+function createBubblesError(message) {
+  return new Error(`[@fishonfire/bubbles-expo] ${message}`);
+}
+function failWithBubblesError(message) {
+  throw createBubblesError(message);
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/internal/validation.ts
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function getRequiredNonEmptyString(value, fieldName) {
+  if (typeof value !== "string") {
+    failWithBubblesError(`"${fieldName}" must be a string.`);
+  }
+  const trimmedValue = value.trim();
+  if (!trimmedValue) {
+    failWithBubblesError(`"${fieldName}" must not be empty.`);
+  }
+  return trimmedValue;
+}
+function getRequiredNonEmptyStringFromSource(value, sourceDescription) {
+  if (typeof value !== "string") {
+    failWithBubblesError(`${sourceDescription} must be a string.`);
+  }
+  const trimmedValue = value.trim();
+  if (!trimmedValue) {
+    failWithBubblesError(`${sourceDescription} must not be empty.`);
+  }
+  return trimmedValue;
+}
+function normalizeIdentifier(value, fieldName) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      failWithBubblesError(
+        `"${fieldName}" must be a finite number when it is numeric.`
+      );
+    }
+    return String(value);
+  }
+  if (typeof value !== "string") {
+    failWithBubblesError(`"${fieldName}" must be a string or number.`);
+  }
+  const trimmedValue = value.trim();
+  if (!trimmedValue) {
+    failWithBubblesError(`"${fieldName}" must not be empty.`);
+  }
+  return trimmedValue;
+}
+
+// src/config/runtime-config.ts
+var BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY2 = BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY;
+var ANDROID_CHANNEL_IMPORTANCE_VALUES2 = ANDROID_CHANNEL_IMPORTANCE_VALUES;
+function getAndroidChannelImportance(value, propertyPath) {
+  if (typeof value !== "string") {
+    failWithBubblesError(
+      `"${propertyPath}" must be one of: ${ANDROID_CHANNEL_IMPORTANCE_VALUES2.join(
+        ", "
+      )}.`
+    );
+  }
+  if (!ANDROID_CHANNEL_IMPORTANCE_VALUES2.includes(
+    value
+  )) {
+    failWithBubblesError(
+      `"${propertyPath}" must be one of: ${ANDROID_CHANNEL_IMPORTANCE_VALUES2.join(
+        ", "
+      )}.`
+    );
+  }
+  return value;
+}
+function getBubblesNotificationsRuntimeConfig() {
+  const expoConfig = import_expo_constants.default.expoConfig;
+  if (!expoConfig) {
+    failWithBubblesError(
+      "Expo runtime config is unavailable. Ensure the app is running with Expo config support."
+    );
+  }
+  if (!isPlainObject(expoConfig.extra)) {
+    failWithBubblesError(
+      `Missing "expo.extra.${BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY2}". Configure the "@fishonfire/bubbles-expo" plugin in app.json.`
+    );
+  }
+  const runtimeConfig = expoConfig.extra[BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY2];
+  if (!isPlainObject(runtimeConfig)) {
+    failWithBubblesError(
+      `Missing "expo.extra.${BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY2}". Configure the "@fishonfire/bubbles-expo" plugin in app.json.`
+    );
+  }
+  return {
+    defaultChannelId: getRequiredNonEmptyString(
+      runtimeConfig.defaultChannelId,
+      `expo.extra.${BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY2}.defaultChannelId`
+    ),
+    defaultChannelName: getRequiredNonEmptyString(
+      runtimeConfig.defaultChannelName,
+      `expo.extra.${BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY2}.defaultChannelName`
+    ),
+    androidChannelImportance: getAndroidChannelImportance(
+      runtimeConfig.androidChannelImportance,
+      `expo.extra.${BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY2}.androidChannelImportance`
+    )
+  };
+}
+
+// src/storage/device-state.ts
+var import_expo_file_system = require("expo-file-system");
+var STORED_DEVICE_STATE_FILE_NAME = "bubbles-notifications-expo-state.json";
+var LEGACY_DEVICE_ID_FILE_NAME = "device-id.txt";
+var STORED_DEVICE_STATE_VERSION = 1;
+function getOptionalNonEmptyString(value, fieldName) {
+  if (value == null) {
+    return null;
+  }
+  if (typeof value !== "string") {
+    failWithBubblesError(`Stored "${fieldName}" must be a string when present.`);
+  }
+  const trimmedValue = value.trim();
+  return trimmedValue.length > 0 ? trimmedValue : null;
+}
+function getStoredDeviceStateFile() {
+  return new import_expo_file_system.File(import_expo_file_system.Paths.document, STORED_DEVICE_STATE_FILE_NAME);
+}
+function getLegacyDeviceIdFile() {
+  return new import_expo_file_system.File(import_expo_file_system.Paths.document, LEGACY_DEVICE_ID_FILE_NAME);
+}
+function readLegacyStoredDeviceId() {
+  const legacyDeviceIdFile = getLegacyDeviceIdFile();
+  if (!legacyDeviceIdFile.exists) {
+    return null;
+  }
+  const storedDeviceId = legacyDeviceIdFile.textSync().trim();
+  return storedDeviceId.length > 0 ? storedDeviceId : null;
+}
+function normalizeStoredDeviceState(value, sourceDescription) {
+  if (!isPlainObject(value)) {
+    failWithBubblesError(
+      `Stored device state in ${sourceDescription} must be a JSON object.`
+    );
+  }
+  if (value.version !== STORED_DEVICE_STATE_VERSION) {
+    failWithBubblesError(
+      `Stored device state in ${sourceDescription} uses unsupported schema version "${String(
+        value.version
+      )}".`
+    );
+  }
+  return {
+    deviceId: getOptionalNonEmptyString(value.deviceId, "deviceId"),
+    apiBaseUrl: getOptionalNonEmptyString(value.apiBaseUrl, "apiBaseUrl"),
+    appKey: getOptionalNonEmptyString(value.appKey, "appKey")
+  };
+}
+function normalizeStoredDeviceStateInput(value) {
+  if (!isPlainObject(value)) {
+    failWithBubblesError("Stored device state must be an object.");
+  }
+  return {
+    deviceId: getOptionalNonEmptyString(value.deviceId, "deviceId"),
+    apiBaseUrl: getOptionalNonEmptyString(value.apiBaseUrl, "apiBaseUrl"),
+    appKey: getOptionalNonEmptyString(value.appKey, "appKey")
+  };
+}
+function normalizeStoredDeviceStateUpdate(value) {
+  if (!isPlainObject(value)) {
+    failWithBubblesError("Stored device state update must be an object.");
+  }
+  const nextState = {};
+  if ("deviceId" in value) {
+    nextState.deviceId = getOptionalNonEmptyString(value.deviceId, "deviceId");
+  }
+  if ("apiBaseUrl" in value) {
+    nextState.apiBaseUrl = getOptionalNonEmptyString(
+      value.apiBaseUrl,
+      "apiBaseUrl"
+    );
+  }
+  if ("appKey" in value) {
+    nextState.appKey = getOptionalNonEmptyString(value.appKey, "appKey");
+  }
+  return nextState;
+}
+function serializeStoredDeviceState(state) {
+  const serializedState = {
+    version: STORED_DEVICE_STATE_VERSION
+  };
+  if (state.deviceId) {
+    serializedState.deviceId = state.deviceId;
+  }
+  if (state.apiBaseUrl) {
+    serializedState.apiBaseUrl = state.apiBaseUrl;
+  }
+  if (state.appKey) {
+    serializedState.appKey = state.appKey;
+  }
+  return serializedState;
+}
+function readStoredDeviceStateFileText() {
+  const storedDeviceStateFile = getStoredDeviceStateFile();
+  if (!storedDeviceStateFile.exists) {
+    return null;
+  }
+  const contents = storedDeviceStateFile.textSync().trim();
+  return contents.length > 0 ? contents : null;
+}
+function ensureStoredDeviceStateFile() {
+  const storedDeviceStateFile = getStoredDeviceStateFile();
+  if (!storedDeviceStateFile.exists) {
+    storedDeviceStateFile.create({ intermediates: true });
+  }
+  return storedDeviceStateFile;
+}
+function withLegacyDeviceIdFallback(state) {
+  if (state.deviceId) {
+    return state;
+  }
+  const legacyDeviceId = readLegacyStoredDeviceId();
+  if (!legacyDeviceId) {
+    return state;
+  }
+  return {
+    ...state,
+    deviceId: legacyDeviceId
+  };
+}
+function readStoredDeviceState() {
+  const storedDeviceStateFile = getStoredDeviceStateFile();
+  const rawState = readStoredDeviceStateFileText();
+  if (rawState === null) {
+    return withLegacyDeviceIdFallback({
+      deviceId: null,
+      apiBaseUrl: null,
+      appKey: null
+    });
+  }
+  let parsedState;
+  try {
+    parsedState = JSON.parse(rawState);
+  } catch {
+    failWithBubblesError(
+      `Stored device state at "${storedDeviceStateFile.uri}" is not valid JSON.`
+    );
+  }
+  return withLegacyDeviceIdFallback(
+    normalizeStoredDeviceState(parsedState, `"${storedDeviceStateFile.uri}"`)
+  );
+}
+function storeDeviceState(state) {
+  const normalizedState = normalizeStoredDeviceStateInput(state);
+  const storedDeviceStateFile = ensureStoredDeviceStateFile();
+  storedDeviceStateFile.write(
+    JSON.stringify(serializeStoredDeviceState(normalizedState), null, 2)
+  );
+  return normalizedState;
+}
+function patchStoredDeviceState(update) {
+  const normalizedUpdate = normalizeStoredDeviceStateUpdate(update);
+  return storeDeviceState({
+    ...readStoredDeviceState(),
+    ...normalizedUpdate
+  });
+}
+function readStoredDeviceId() {
+  return readStoredDeviceState().deviceId;
+}
+function readStoredApiBaseUrl() {
+  return readStoredDeviceState().apiBaseUrl;
+}
+function readStoredAppKey() {
+  return readStoredDeviceState().appKey;
+}
+function storeDeviceId(deviceId) {
+  return patchStoredDeviceState({ deviceId });
+}
+function storeApiBaseUrl(apiBaseUrl) {
+  return patchStoredDeviceState({ apiBaseUrl });
+}
+function storeAppKey(appKey) {
+  return patchStoredDeviceState({ appKey });
+}
+
+// src/api/device-client.ts
+var import_bubbles_js2 = require("@fishonfire/bubbles-js");
+
+// src/api/device-payload.ts
+var import_bubbles_js = require("@fishonfire/bubbles-js");
+function normalizeOptionalString(value, fieldName) {
+  if (value == null) {
+    return null;
+  }
+  if (typeof value !== "string") {
+    failWithBubblesError(`"${fieldName}" must be a string when present.`);
+  }
+  const trimmedValue = value.trim();
+  return trimmedValue.length > 0 ? trimmedValue : null;
+}
+function normalizeRequiredNullableString(value, fieldName) {
+  if (value === null) {
+    return null;
+  }
+  if (value === void 0) {
+    failWithBubblesError(
+      `"${fieldName}" is required. Pass a push token string or null.`
+    );
+  }
+  return getRequiredNonEmptyString(value, fieldName);
+}
+function normalizeAppId(value) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      failWithBubblesError('"appId" must be a finite number.');
+    }
+    return value;
+  }
+  if (typeof value === "string") {
+    return getRequiredNonEmptyString(value, "appId");
+  }
+  failWithBubblesError('"appId" must be a string or number.');
+}
+function normalizePlatform(value) {
+  if (value === "android" || value === "ios") {
+    return value;
+  }
+  failWithBubblesError('"platform" must be either "android" or "ios".');
+}
+function normalizeAliasing(value) {
+  if (value == null) {
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    failWithBubblesError('"aliasing" must be an array of strings when present.');
+  }
+  return value.map(
+    (entry, index) => normalizeOptionalString(entry, `aliasing[${index}]`)
+  ).filter((entry) => entry !== null);
+}
+function normalizeNotificationsEnabled(value) {
+  if (typeof value !== "boolean") {
+    failWithBubblesError('"notificationsEnabled" must be a boolean.');
+  }
+  return value;
+}
+function resolveLocaleAndTimeZone(input) {
+  const resolved = input ?? (0, import_bubbles_js.getLocaleAndTimeZone)();
+  return {
+    locale: getRequiredNonEmptyString(resolved.locale, "locale"),
+    timeZone: normalizeOptionalString(resolved.timeZone, "timeZone")
+  };
+}
+function buildBaseDevicePayload(options) {
+  const { locale, timeZone } = resolveLocaleAndTimeZone(
+    options.localeAndTimeZone
+  );
+  const payload = {
+    user_id: getRequiredNonEmptyString(options.userId, "userId"),
+    aliasing: normalizeAliasing(options.aliasing),
+    platform: normalizePlatform(options.platform),
+    push_token: normalizeRequiredNullableString(options.pushToken, "pushToken"),
+    locale,
+    notifications_enabled: normalizeNotificationsEnabled(
+      options.notificationsEnabled
+    )
+  };
+  if ("fid" in options) {
+    payload.fid = normalizeOptionalString(options.fid, "fid");
+  }
+  const appVersion = normalizeOptionalString(options.appVersion, "appVersion");
+  if (appVersion) {
+    payload.app_version = appVersion;
+  }
+  if (timeZone) {
+    payload.timezone = timeZone;
+  }
+  return payload;
+}
+function buildCreateDevicePayload(options) {
+  return {
+    app_id: normalizeAppId(options.appId),
+    ...buildBaseDevicePayload(options)
+  };
+}
+function buildUpdateDevicePayload(options) {
+  return buildBaseDevicePayload(options);
+}
+
+// src/api/device-client.ts
+var APP_KEY_HEADER_NAME = "X-App-Key";
+var INVALID_APP_KEY_ERROR = "invalid app key for app";
+var BubblesAppAuthenticationError = class extends Error {
+  constructor(cause) {
+    super("Bubbles app configuration/authentication failed: invalid app key for app.");
+    this.name = "BubblesAppAuthenticationError";
+    this.cause = cause;
+  }
+};
+function resolveDeviceClient(options) {
+  if (options.client) {
+    return options.client;
+  }
+  return createBubblesDeviceClient({
+    ...options.clientOptions,
+    appKey: options.appKey,
+    baseUrl: getRequiredNonEmptyString(options.apiBaseUrl, "apiBaseUrl")
+  });
+}
+function createBubblesDeviceClient(options) {
+  const { appKey: rawAppKey, ...clientOptions } = options;
+  const appKey = rawAppKey ? getRequiredNonEmptyString(rawAppKey, "appKey") : null;
+  return new import_bubbles_js2.DeviceClient({
+    ...clientOptions,
+    baseUrl: getRequiredNonEmptyString(clientOptions.baseUrl, "apiBaseUrl"),
+    defaultHeaders: {
+      ...clientOptions.defaultHeaders,
+      ...appKey ? { [APP_KEY_HEADER_NAME]: appKey } : {}
+    }
+  });
+}
+function withAppKeyHeader(appKey, requestOptions) {
+  return {
+    ...requestOptions,
+    headers: {
+      ...requestOptions?.headers,
+      [APP_KEY_HEADER_NAME]: getRequiredNonEmptyString(appKey, "appKey")
+    }
+  };
+}
+function isInvalidAppKeyResponse(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const status = Reflect.get(error, "status");
+  const body = Reflect.get(error, "body");
+  return status === 401 && !!body && typeof body === "object" && !Array.isArray(body) && Reflect.get(body, "error") === INVALID_APP_KEY_ERROR;
+}
+function throwAppAuthenticationError(error) {
+  if (isInvalidAppKeyResponse(error)) {
+    throw new BubblesAppAuthenticationError(error);
+  }
+  throw error;
+}
+function extractDeviceIdFromDeviceResponse(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const id = Reflect.get(value, "id");
+  if (typeof id === "number") {
+    return Number.isFinite(id) ? String(id) : null;
+  }
+  if (typeof id === "string") {
+    const trimmedId = id.trim();
+    return trimmedId.length > 0 ? trimmedId : null;
+  }
+  return null;
+}
+async function createBubblesDevice(options) {
+  const client = resolveDeviceClient(options);
+  const payload = buildCreateDevicePayload(options);
+  try {
+    return await client.createDevice(
+      payload,
+      withAppKeyHeader(options.appKey, options.requestOptions)
+    );
+  } catch (error) {
+    throwAppAuthenticationError(error);
+  }
+}
+async function updateBubblesDevice(options) {
+  const client = resolveDeviceClient(options);
+  const payload = buildUpdateDevicePayload(options);
+  try {
+    return await client.updateDevice(
+      normalizeIdentifier(options.deviceId, "deviceId"),
+      payload,
+      withAppKeyHeader(options.appKey, options.requestOptions)
+    );
+  } catch (error) {
+    throwAppAuthenticationError(error);
+  }
+}
+async function syncBubblesDevice(options) {
+  const client = resolveDeviceClient(options);
+  if (options.deviceId !== null) {
+    const deviceId = normalizeIdentifier(options.deviceId, "deviceId");
+    let response2;
+    try {
+      response2 = await client.updateDevice(
+        deviceId,
+        buildUpdateDevicePayload(options),
+        withAppKeyHeader(options.appKey, options.updateRequestOptions)
+      );
+    } catch (error) {
+      throwAppAuthenticationError(error);
+    }
+    return {
+      action: "updated",
+      deviceId,
+      response: response2
+    };
+  }
+  let response;
+  try {
+    response = await client.createDevice(
+      buildCreateDevicePayload(options),
+      withAppKeyHeader(options.appKey, options.createRequestOptions)
+    );
+  } catch (error) {
+    throwAppAuthenticationError(error);
+  }
+  return {
+    action: "created",
+    deviceId: extractDeviceIdFromDeviceResponse(response),
+    response
+  };
+}
+
+// src/api/delivery-status.ts
+var BUBBLES_DELIVERY_STATUSES = {
+  notificationReceived: "received",
+  notificationShown: "shown",
+  notificationClicked: "clicked",
+  notificationsDisabled: "disabled"
+};
+function normalizeError(value) {
+  if (value == null) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    failWithBubblesError('"error" must be a string when present.');
+  }
+  const trimmedValue = value.trim();
+  if (!trimmedValue) {
+    failWithBubblesError('"error" must not be empty when present.');
+  }
+  return trimmedValue;
+}
+function normalizeStatus(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const supportedValues = Object.values(BUBBLES_DELIVERY_STATUSES);
+  if (typeof value !== "string" || !supportedValues.includes(value)) {
+    failWithBubblesError(
+      `"status" must be one of: ${supportedValues.join(", ")}.`
+    );
+  }
+  return value;
+}
+function resolveDeviceClient2(options) {
+  if (options.client) {
+    return options.client;
+  }
+  return createBubblesDeviceClient({
+    ...options.clientOptions,
+    appKey: getRequiredNonEmptyString(options.appKey, "appKey"),
+    baseUrl: getRequiredNonEmptyString(options.apiBaseUrl, "apiBaseUrl")
+  });
+}
+function withAppKeyHeader2(appKey, requestOptions) {
+  return {
+    ...requestOptions,
+    headers: {
+      ...requestOptions?.headers,
+      "X-App-Key": getRequiredNonEmptyString(appKey, "appKey")
+    }
+  };
+}
+function isInvalidAppKeyResponse2(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const status = Reflect.get(error, "status");
+  const body = Reflect.get(error, "body");
+  return status === 401 && !!body && typeof body === "object" && !Array.isArray(body) && Reflect.get(body, "error") === "invalid app key for app";
+}
+function buildBubblesDeliveryStatusPayload(options) {
+  const status = normalizeStatus(options.status);
+  const error = normalizeError(options.error);
+  if (!status && !error) {
+    failWithBubblesError(
+      'A delivery status payload must include "status" and/or "error".'
+    );
+  }
+  return {
+    ...status ? { status } : {},
+    ...error ? { error } : {}
+  };
+}
+async function postBubblesDeliveryStatus(options) {
+  const client = resolveDeviceClient2(options);
+  try {
+    await client.postDeliveryStatus(
+      normalizeIdentifier(options.deviceId, "deviceId"),
+      normalizeIdentifier(options.notificationId, "notificationId"),
+      buildBubblesDeliveryStatusPayload(options),
+      withAppKeyHeader2(options.appKey, options.requestOptions)
+    );
+  } catch (error) {
+    if (isInvalidAppKeyResponse2(error)) {
+      throw new BubblesAppAuthenticationError(error);
+    }
+    throw error;
+  }
+}
+
+// src/storage/delivery-status-ledger.ts
+var import_expo_file_system2 = require("expo-file-system");
+var DELIVERY_STATUS_LEDGER_FILE_NAME = "bubbles-notifications-expo-delivery-status-ledger.json";
+var DELIVERY_STATUS_LEDGER_VERSION = 1;
+var MAX_POSTED_EVENT_KEYS = 200;
+function getDeliveryStatusLedgerFile() {
+  return new import_expo_file_system2.File(import_expo_file_system2.Paths.document, DELIVERY_STATUS_LEDGER_FILE_NAME);
+}
+function getOptionalNonEmptyString2(value) {
+  if (value == null) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmedValue = value.trim();
+  return trimmedValue.length > 0 ? trimmedValue : void 0;
+}
+function requireString(value, sourceDescription) {
+  if (typeof value !== "string") {
+    failWithBubblesError(`${sourceDescription} must be a string.`);
+  }
+  const trimmedValue = value.trim();
+  if (!trimmedValue) {
+    failWithBubblesError(`${sourceDescription} must not be empty.`);
+  }
+  return trimmedValue;
+}
+function buildStoredDeliveryStatusEventKey(options) {
+  return JSON.stringify([
+    options.notificationId,
+    options.status ?? null,
+    options.error ?? null,
+    options.actionId ?? null
+  ]);
+}
+function createStoredDeliveryStatusEvent(options) {
+  const error = getOptionalNonEmptyString2(options.error);
+  const actionId = getOptionalNonEmptyString2(options.actionId);
+  return {
+    key: buildStoredDeliveryStatusEventKey({
+      notificationId: options.notificationId,
+      status: options.status,
+      error,
+      actionId
+    }),
+    notificationId: options.notificationId,
+    ...options.status ? { status: options.status } : {},
+    ...error ? { error } : {},
+    ...actionId ? { actionId } : {},
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function normalizeStoredDeliveryStatusEvent(value, sourceDescription) {
+  if (!isPlainObject(value)) {
+    failWithBubblesError(`${sourceDescription} must be a JSON object.`);
+  }
+  const status = getOptionalNonEmptyString2(value.status);
+  const error = getOptionalNonEmptyString2(value.error);
+  const actionId = getOptionalNonEmptyString2(value.actionId);
+  return {
+    key: requireString(value.key, `${sourceDescription}.key`),
+    notificationId: requireString(
+      value.notificationId,
+      `${sourceDescription}.notificationId`
+    ),
+    ...status ? { status } : {},
+    ...error ? { error } : {},
+    ...actionId ? { actionId } : {},
+    createdAt: requireString(value.createdAt, `${sourceDescription}.createdAt`)
+  };
+}
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((item) => getOptionalNonEmptyString2(item)).filter((item) => item !== void 0);
+}
+function normalizeDeliveryStatusLedger(value, sourceDescription) {
+  if (!isPlainObject(value)) {
+    failWithBubblesError(
+      `Stored delivery status ledger in ${sourceDescription} must be a JSON object.`
+    );
+  }
+  if (value.version !== DELIVERY_STATUS_LEDGER_VERSION) {
+    failWithBubblesError(
+      `Stored delivery status ledger in ${sourceDescription} uses unsupported schema version "${String(
+        value.version
+      )}".`
+    );
+  }
+  return {
+    pendingEvents: Array.isArray(value.pendingEvents) ? value.pendingEvents.map(
+      (event, index) => normalizeStoredDeliveryStatusEvent(
+        event,
+        `${sourceDescription}.pendingEvents[${index}]`
+      )
+    ) : [],
+    postedEventKeys: normalizeStringArray(value.postedEventKeys).slice(
+      -MAX_POSTED_EVENT_KEYS
+    )
+  };
+}
+function serializeDeliveryStatusLedger(ledger) {
+  return {
+    version: DELIVERY_STATUS_LEDGER_VERSION,
+    pendingEvents: ledger.pendingEvents,
+    postedEventKeys: ledger.postedEventKeys.slice(-MAX_POSTED_EVENT_KEYS)
+  };
+}
+function readDeliveryStatusLedgerFileText() {
+  const ledgerFile = getDeliveryStatusLedgerFile();
+  if (!ledgerFile.exists) {
+    return null;
+  }
+  const contents = ledgerFile.textSync().trim();
+  return contents.length > 0 ? contents : null;
+}
+function ensureDeliveryStatusLedgerFile() {
+  const ledgerFile = getDeliveryStatusLedgerFile();
+  if (!ledgerFile.exists) {
+    ledgerFile.create({ intermediates: true });
+  }
+  return ledgerFile;
+}
+function readStoredDeliveryStatusLedger() {
+  const ledgerFile = getDeliveryStatusLedgerFile();
+  const rawLedger = readDeliveryStatusLedgerFileText();
+  if (rawLedger === null) {
+    return {
+      pendingEvents: [],
+      postedEventKeys: []
+    };
+  }
+  let parsedLedger;
+  try {
+    parsedLedger = JSON.parse(rawLedger);
+  } catch {
+    failWithBubblesError(
+      `Stored delivery status ledger at "${ledgerFile.uri}" is not valid JSON.`
+    );
+  }
+  return normalizeDeliveryStatusLedger(
+    parsedLedger,
+    `"${ledgerFile.uri}"`
+  );
+}
+function storeDeliveryStatusLedger(ledger) {
+  const normalizedLedger = {
+    pendingEvents: ledger.pendingEvents,
+    postedEventKeys: ledger.postedEventKeys.slice(-MAX_POSTED_EVENT_KEYS)
+  };
+  const ledgerFile = ensureDeliveryStatusLedgerFile();
+  ledgerFile.write(
+    JSON.stringify(serializeDeliveryStatusLedger(normalizedLedger), null, 2)
+  );
+  return normalizedLedger;
+}
+function enqueueStoredDeliveryStatusEvent(event) {
+  const ledger = readStoredDeliveryStatusLedger();
+  if (ledger.postedEventKeys.includes(event.key) || ledger.pendingEvents.some((pendingEvent) => pendingEvent.key === event.key)) {
+    return ledger;
+  }
+  return storeDeliveryStatusLedger({
+    ...ledger,
+    pendingEvents: [...ledger.pendingEvents, event]
+  });
+}
+function markStoredDeliveryStatusEventPosted(event) {
+  const ledger = readStoredDeliveryStatusLedger();
+  const postedEventKeys = ledger.postedEventKeys.includes(event.key) ? ledger.postedEventKeys : [...ledger.postedEventKeys, event.key];
+  return storeDeliveryStatusLedger({
+    pendingEvents: ledger.pendingEvents.filter(
+      (pendingEvent) => pendingEvent.key !== event.key
+    ),
+    postedEventKeys
+  });
+}
+
+// src/notifications/delivery-status.ts
+function warnMissingApiBaseUrl(source) {
+  console.warn(
+    `[@fishonfire/bubbles-expo] Skipping ${source} delivery-status update because "apiBaseUrl" has not been persisted yet.`
+  );
+}
+function warnMissingAppKey(source) {
+  console.warn(
+    `[@fishonfire/bubbles-expo] Skipping ${source} delivery-status update because "appKey" has not been persisted yet.`
+  );
+}
+async function postStoredBubblesDeliveryStatus(options) {
+  const storedDeviceState = options.storedDeviceState ?? readStoredDeviceState();
+  const { deviceId, apiBaseUrl, appKey } = storedDeviceState;
+  if (!options.notificationId) {
+    return storedDeviceState;
+  }
+  const event = createStoredDeliveryStatusEvent({
+    notificationId: options.notificationId,
+    status: options.status,
+    error: options.error,
+    actionId: options.actionId
+  });
+  enqueueStoredDeliveryStatusEvent(event);
+  if (!deviceId) {
+    return storedDeviceState;
+  }
+  if (!apiBaseUrl) {
+    warnMissingApiBaseUrl(options.source);
+    return storedDeviceState;
+  }
+  if (!appKey) {
+    warnMissingAppKey(options.source);
+    return storedDeviceState;
+  }
+  await flushStoredBubblesDeliveryStatuses({
+    apiBaseUrl,
+    appKey,
+    deviceId
+  });
+  return storedDeviceState;
+}
+async function flushStoredBubblesDeliveryStatuses(storedDeviceState = readStoredDeviceState()) {
+  const { deviceId, apiBaseUrl, appKey } = storedDeviceState;
+  if (!deviceId || !apiBaseUrl || !appKey) {
+    return storedDeviceState;
+  }
+  const { pendingEvents } = readStoredDeliveryStatusLedger();
+  for (const event of pendingEvents) {
+    await postStoredDeliveryStatusEvent(apiBaseUrl, appKey, deviceId, event);
+    markStoredDeliveryStatusEventPosted(event);
+  }
+  return storedDeviceState;
+}
+async function postStoredDeliveryStatusEvent(apiBaseUrl, appKey, deviceId, event) {
+  await postBubblesDeliveryStatus({
+    apiBaseUrl,
+    appKey,
+    deviceId,
+    notificationId: event.notificationId,
+    status: event.status,
+    error: event.error
+  });
+}
+
+// src/runtime/channels.ts
+var Notifications = __toESM(require("expo-notifications"));
+var import_react_native = require("react-native");
+var ANDROID_CHANNEL_IMPORTANCE_MAP = {
+  min: Notifications.AndroidImportance.MIN,
+  low: Notifications.AndroidImportance.LOW,
+  default: Notifications.AndroidImportance.DEFAULT,
+  high: Notifications.AndroidImportance.HIGH,
+  max: Notifications.AndroidImportance.MAX
+};
+function fail(message) {
+  throw new Error(`[@fishonfire/bubbles-expo] ${message}`);
+}
+function getRequiredNonEmptyString2(value, fieldName) {
+  if (typeof value !== "string") {
+    fail(`"${fieldName}" must be a string.`);
+  }
+  const trimmedValue = value.trim();
+  if (!trimmedValue) {
+    fail(`"${fieldName}" must not be empty.`);
+  }
+  return trimmedValue;
+}
+function getAndroidNotificationChannelImportance(value) {
+  return ANDROID_CHANNEL_IMPORTANCE_MAP[value];
+}
+function getDefaultNotificationChannelConfig(options) {
+  const runtimeConfig = getBubblesNotificationsRuntimeConfig();
+  return {
+    channelId: getRequiredNonEmptyString2(
+      options?.channelId ?? runtimeConfig.defaultChannelId,
+      "channelId"
+    ),
+    channelName: getRequiredNonEmptyString2(
+      options?.channelName ?? runtimeConfig.defaultChannelName,
+      "channelName"
+    ),
+    importance: options?.importance ?? runtimeConfig.androidChannelImportance
+  };
+}
+async function ensureDefaultNotificationChannel(options) {
+  if (import_react_native.Platform.OS !== "android") {
+    return null;
+  }
+  const channelConfig = getDefaultNotificationChannelConfig(options);
+  return Notifications.setNotificationChannelAsync(channelConfig.channelId, {
+    name: channelConfig.channelName,
+    importance: getAndroidNotificationChannelImportance(channelConfig.importance)
+  });
+}
+
+// src/background/firebase-message-handler.ts
+var import_messaging = require("@react-native-firebase/messaging");
+var Notifications4 = __toESM(require("expo-notifications"));
+var import_react_native3 = require("react-native");
+
+// src/notifications/local-notification.ts
+var Notifications3 = __toESM(require("expo-notifications"));
+
+// src/runtime/permissions.ts
+var Notifications2 = __toESM(require("expo-notifications"));
+var import_react_native2 = require("react-native");
+
+// src/internal/platform.ts
+function isSupportedPlatform(value) {
+  return value === "android" || value === "ios";
+}
+function assertSupportedPlatform(value) {
+  if (isSupportedPlatform(value)) {
+    return;
+  }
+  failWithBubblesError(
+    `Unsupported platform: ${value}. This package only supports iOS and Android.`
+  );
+}
+function getSupportedPlatform(value) {
+  assertSupportedPlatform(value);
+  return value;
+}
+
+// src/runtime/permissions.ts
+var IOS_GRANTED_AUTHORIZATION_STATUSES = /* @__PURE__ */ new Set([
+  Notifications2.IosAuthorizationStatus.AUTHORIZED,
+  Notifications2.IosAuthorizationStatus.PROVISIONAL,
+  Notifications2.IosAuthorizationStatus.EPHEMERAL
+]);
+function isNotificationPermissionGranted(permissions) {
+  if (import_react_native2.Platform.OS === "ios" && permissions.ios?.status != null) {
+    return IOS_GRANTED_AUTHORIZATION_STATUSES.has(permissions.ios.status);
+  }
+  return permissions.granted;
+}
+function describeNotificationPermissionStatus(permissions) {
+  if (import_react_native2.Platform.OS === "ios" && permissions.ios?.status != null) {
+    return Notifications2.IosAuthorizationStatus[permissions.ios.status].toLowerCase();
+  }
+  return permissions.status;
+}
+async function getNotificationPermissions(options) {
+  assertSupportedPlatform(import_react_native2.Platform.OS);
+  await ensureDefaultNotificationChannel();
+  const existingPermissions = await Notifications2.getPermissionsAsync();
+  if (isNotificationPermissionGranted(existingPermissions) || options?.requestPermissions === false) {
+    return existingPermissions;
+  }
+  return Notifications2.requestPermissionsAsync(options?.permissionRequestOptions);
+}
+async function ensureNotificationPermissions(options) {
+  const permissions = await getNotificationPermissions(options);
+  if (!isNotificationPermissionGranted(permissions)) {
+    failWithBubblesError("Push notification permission was not granted.");
+  }
+  return permissions;
+}
+
+// src/notifications/local-notification.ts
+var DEFAULT_LOCAL_NOTIFICATION_TITLE = "Notification received";
+var DEFAULT_LOCAL_NOTIFICATION_BODY = "Open the app to view this update.";
+var DUPLICATE_NOTIFICATION_WINDOW_MS = 5e3;
+var recentlyScheduledNotificationKeys = /* @__PURE__ */ new Map();
+function getOptionalNonEmptyString3(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmedValue = value.trim();
+  return trimmedValue.length > 0 ? trimmedValue : null;
+}
+function buildDuplicateNotificationKey(payload) {
+  if (payload.notificationId) {
+    return `notification:${payload.notificationId}`;
+  }
+  const dataKeys = Object.keys(payload.data);
+  if (dataKeys.length === 0) {
+    return null;
+  }
+  try {
+    return `data:${JSON.stringify(payload.data)}`;
+  } catch {
+    return null;
+  }
+}
+function rememberScheduledNotificationKey(duplicateKey) {
+  const now = Date.now();
+  for (const [key, timestamp] of recentlyScheduledNotificationKeys) {
+    if (now - timestamp > DUPLICATE_NOTIFICATION_WINDOW_MS) {
+      recentlyScheduledNotificationKeys.delete(key);
+    }
+  }
+  const previousTimestamp = recentlyScheduledNotificationKeys.get(duplicateKey);
+  if (previousTimestamp !== void 0 && now - previousTimestamp <= DUPLICATE_NOTIFICATION_WINDOW_MS) {
+    return false;
+  }
+  recentlyScheduledNotificationKeys.set(duplicateKey, now);
+  return true;
+}
+async function postLocalNotificationShownDeliveryStatus(options) {
+  try {
+    await postStoredBubblesDeliveryStatus({
+      source: options.source,
+      notificationId: options.payload.notificationId,
+      status: BUBBLES_DELIVERY_STATUSES.notificationShown
+    });
+  } catch (error) {
+    console.error(
+      `[@fishonfire/bubbles-expo] Failed to post ${options.source} shown delivery status.`,
+      error
+    );
+  }
+}
+function buildBubblesLocalNotificationRequest(payload, options) {
+  return {
+    content: {
+      title: payload.messageTitle ?? getOptionalNonEmptyString3(options?.title) ?? DEFAULT_LOCAL_NOTIFICATION_TITLE,
+      body: payload.body ?? getOptionalNonEmptyString3(options?.body) ?? DEFAULT_LOCAL_NOTIFICATION_BODY,
+      data: payload.data
+    },
+    // Force app to trigger it 1 second from now instead of null.
+    // This prevents issues during background handling.
+    trigger: {
+      type: Notifications3.SchedulableTriggerInputTypes.TIME_INTERVAL,
+      seconds: 1
+    }
+  };
+}
+async function scheduleBubblesLocalNotification(options) {
+  if (!options.skipPermissionCheck) {
+    const permissions = await Notifications3.getPermissionsAsync();
+    const notificationsEnabled = isNotificationPermissionGranted(permissions);
+    if (!notificationsEnabled) {
+      return null;
+    }
+  }
+  const duplicateKey = buildDuplicateNotificationKey(options.payload);
+  if (duplicateKey !== null && !rememberScheduledNotificationKey(duplicateKey)) {
+    return null;
+  }
+  const notificationRequest = buildBubblesLocalNotificationRequest(
+    options.payload,
+    options
+  );
+  const scheduledNotificationId = await Notifications3.scheduleNotificationAsync(
+    notificationRequest
+  );
+  await postLocalNotificationShownDeliveryStatus(options);
+  return scheduledNotificationId;
+}
+
+// src/notifications/payload.ts
+function isPlainObject2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function getOptionalNonEmptyString4(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmedValue = value.trim();
+  return trimmedValue.length > 0 ? trimmedValue : null;
+}
+function getOptionalIdentifier(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? String(value) : null;
+  }
+  return getOptionalNonEmptyString4(value);
+}
+function getBubblesNotificationData(value) {
+  return isPlainObject2(value) ? value : {};
+}
+function getBubblesNotificationDataFromNotification(notification) {
+  return getBubblesNotificationData(notification.request.content.data);
+}
+function normalizeBubblesNotificationPayload(value) {
+  const data = getBubblesNotificationData(value);
+  return {
+    data,
+    notificationId: getOptionalIdentifier(data.notification_id),
+    messageTitle: getOptionalNonEmptyString4(data.message_title),
+    body: getOptionalNonEmptyString4(data.body),
+    source: getOptionalNonEmptyString4(data.source),
+    messageId: getOptionalIdentifier(data.message_id),
+    campaignId: getOptionalIdentifier(data.campaign_id),
+    url: getOptionalNonEmptyString4(data.url)
+  };
+}
+
+// src/notifications/remote-message.ts
+function getOptionalNonEmptyString5(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const trimmedValue = value.trim();
+  return trimmedValue.length > 0 ? trimmedValue : null;
+}
+function getBubblesNotificationPayloadFromRemoteMessage(remoteMessage) {
+  const payload = normalizeBubblesNotificationPayload(
+    getBubblesNotificationData(remoteMessage.data)
+  );
+  return {
+    ...payload,
+    messageTitle: payload.messageTitle ?? getOptionalNonEmptyString5(remoteMessage.notification?.title),
+    body: payload.body ?? getOptionalNonEmptyString5(remoteMessage.notification?.body)
+  };
+}
+function hasFirebaseDisplayNotification(remoteMessage) {
+  return getOptionalNonEmptyString5(remoteMessage.notification?.title) !== null || getOptionalNonEmptyString5(remoteMessage.notification?.body) !== null;
+}
+
+// src/background/firebase-message-handler.ts
+var BACKGROUND_NOTIFICATION_SOURCE = "Firebase background message";
+var DEFAULT_BACKGROUND_NOTIFICATION_TITLE = "Background notification received";
+var DEFAULT_BACKGROUND_NOTIFICATION_BODY = "Open the app to view this update.";
+function supportsFirebaseBackgroundMessages() {
+  return import_react_native3.Platform.OS === "android" || import_react_native3.Platform.OS === "ios";
+}
+function supportsBackgroundLocalNotificationPresentation() {
+  return import_react_native3.Platform.OS === "android";
+}
+function logBackgroundStatusError(description, error) {
+  console.error(
+    `[@fishonfire/bubbles-expo] Failed to post ${BACKGROUND_NOTIFICATION_SOURCE} ${description} delivery status.`,
+    error
+  );
+}
+function getBackgroundNotificationErrorMessage(error) {
+  if (!(error instanceof Error)) {
+    return "Failed to show notification";
+  }
+  return `Failed to show notification: ${getErrorMessage(error)}`;
+}
+async function postBackgroundDeliveryStatus(notificationId, status) {
+  try {
+    await postStoredBubblesDeliveryStatus({
+      source: BACKGROUND_NOTIFICATION_SOURCE,
+      notificationId,
+      status
+    });
+  } catch (error) {
+    logBackgroundStatusError(status, error);
+  }
+}
+async function postBackgroundDeliveryError(notificationId, errorMessage) {
+  try {
+    await postStoredBubblesDeliveryStatus({
+      source: BACKGROUND_NOTIFICATION_SOURCE,
+      notificationId,
+      error: errorMessage
+    });
+  } catch (error) {
+    logBackgroundStatusError("error", error);
+  }
+}
+function postBackgroundNotificationReceived(notificationId) {
+  return postBackgroundDeliveryStatus(
+    notificationId,
+    BUBBLES_DELIVERY_STATUSES.notificationReceived
+  );
+}
+function postBackgroundNotificationsDisabled(notificationId) {
+  return postBackgroundDeliveryStatus(
+    notificationId,
+    BUBBLES_DELIVERY_STATUSES.notificationsDisabled
+  );
+}
+var hasRegisteredFirebaseBackgroundMessageHandler = false;
+var handleBubblesFirebaseBackgroundMessage = async (remoteMessage) => {
+  const payload = getBubblesNotificationPayloadFromRemoteMessage(remoteMessage);
+  const permissions = await Notifications4.getPermissionsAsync();
+  const notificationsEnabled = isNotificationPermissionGranted(permissions);
+  if (!notificationsEnabled) {
+    await postBackgroundNotificationsDisabled(payload.notificationId);
+    return;
+  }
+  await postBackgroundNotificationReceived(payload.notificationId);
+  if (hasFirebaseDisplayNotification(remoteMessage)) {
+    return;
+  }
+  if (!supportsBackgroundLocalNotificationPresentation()) {
+    return;
+  }
+  try {
+    const scheduledNotificationId = await scheduleBubblesLocalNotification({
+      source: BACKGROUND_NOTIFICATION_SOURCE,
+      payload,
+      title: DEFAULT_BACKGROUND_NOTIFICATION_TITLE,
+      body: DEFAULT_BACKGROUND_NOTIFICATION_BODY,
+      skipPermissionCheck: true
+    });
+    if (scheduledNotificationId === null) {
+      return;
+    }
+  } catch (error) {
+    await postBackgroundDeliveryError(
+      payload.notificationId,
+      getBackgroundNotificationErrorMessage(error)
+    );
+    throw error;
+  }
+};
+function registerBubblesFirebaseBackgroundMessageHandler() {
+  if (hasRegisteredFirebaseBackgroundMessageHandler) {
+    return;
+  }
+  if (!supportsFirebaseBackgroundMessages()) {
+    return;
+  }
+  try {
+    (0, import_messaging.setBackgroundMessageHandler)(
+      (0, import_messaging.getMessaging)(),
+      handleBubblesFirebaseBackgroundMessage
+    );
+    hasRegisteredFirebaseBackgroundMessageHandler = true;
+  } catch (error) {
+    console.error(
+      "[@fishonfire/bubbles-expo] Failed to register Firebase background message handler.",
+      error
+    );
+  }
+}
+
+// src/background/setup.ts
+var hasRegisteredBubblesBackgroundHandlers = false;
+function registerBubblesBackgroundHandlers() {
+  if (hasRegisteredBubblesBackgroundHandlers) {
+    return;
+  }
+  registerBubblesFirebaseBackgroundMessageHandler();
+  hasRegisteredBubblesBackgroundHandlers = true;
+}
+
+// src/runtime/tokens.ts
+var import_messaging2 = require("@react-native-firebase/messaging");
+var import_react_native4 = require("react-native");
+async function getFirebaseMessagingToken(platform) {
+  try {
+    const messagingInstance = (0, import_messaging2.getMessaging)();
+    if (!(0, import_messaging2.isDeviceRegisteredForRemoteMessages)(messagingInstance)) {
+      await (0, import_messaging2.registerDeviceForRemoteMessages)(messagingInstance);
+    }
+    const token = await (0, import_messaging2.getToken)(messagingInstance);
+    return getRequiredNonEmptyStringFromSource(
+      token,
+      `${platform} FCM token from Firebase Messaging`
+    );
+  } catch (error) {
+    const reason = getErrorMessage(error);
+    const platformSpecificSetupHint = platform === "ios" ? " On iOS, also ensure Firebase APNs setup is complete and `expo.ios.googleServicesFile` is configured." : " On Android, ensure `google-services.json` is configured and the native app has been rebuilt.";
+    failWithBubblesError(
+      `Failed to get a ${platform} FCM token from Firebase Messaging. Ensure "@react-native-firebase/app" and "@react-native-firebase/messaging" are installed, the Expo app includes the "@react-native-firebase/messaging" config plugin, and Firebase is configured for this platform.${platformSpecificSetupHint} Original error: ${reason}`
+    );
+  }
+}
+async function getDeviceRegistrationState(options) {
+  const platform = getSupportedPlatform(import_react_native4.Platform.OS);
+  const permissions = await getNotificationPermissions(options);
+  const permissionStatus = describeNotificationPermissionStatus(permissions);
+  const notificationsEnabled = isNotificationPermissionGranted(permissions);
+  if (!notificationsEnabled) {
+    return {
+      platform,
+      tokenType: null,
+      token: null,
+      permissionStatus,
+      notificationsEnabled: false
+    };
+  }
+  const token = await getFirebaseMessagingToken(platform);
+  return {
+    platform,
+    tokenType: "fcm",
+    token,
+    permissionStatus,
+    notificationsEnabled: true
+  };
+}
+async function getDeviceToken(options) {
+  const registrationState = await getDeviceRegistrationState(options);
+  if (!registrationState.notificationsEnabled || !registrationState.token) {
+    failWithBubblesError("Push notification permission was not granted.");
+  }
+  return {
+    platform: registrationState.platform,
+    tokenType: "fcm",
+    token: registrationState.token
+  };
+}
+async function getFCMToken(options) {
+  const tokenResult = await getDeviceToken(options);
+  return tokenResult.token;
+}
+
+// src/runtime/BubblesNotificationsProvider.tsx
+var import_react3 = require("react");
+
+// src/runtime/context.ts
+var import_react = require("react");
+var BubblesNotificationsContext = (0, import_react.createContext)(null);
+
+// src/runtime/notification-handler.ts
+var Notifications5 = __toESM(require("expo-notifications"));
+var DEFAULT_FOREGROUND_PRESENTATION = {
+  shouldShowBanner: true,
+  shouldShowList: true,
+  shouldPlaySound: false,
+  shouldSetBadge: false
+};
+function applyBubblesNotificationHandler(options) {
+  Notifications5.setNotificationHandler({
+    handleNotification: async (notification) => {
+      const presentation = {
+        shouldShowBanner: options?.shouldShowBanner ?? DEFAULT_FOREGROUND_PRESENTATION.shouldShowBanner,
+        shouldShowList: options?.shouldShowList ?? DEFAULT_FOREGROUND_PRESENTATION.shouldShowList,
+        shouldPlaySound: options?.shouldPlaySound ?? DEFAULT_FOREGROUND_PRESENTATION.shouldPlaySound,
+        shouldSetBadge: options?.shouldSetBadge ?? DEFAULT_FOREGROUND_PRESENTATION.shouldSetBadge
+      };
+      return presentation;
+    }
+  });
+}
+function clearBubblesNotificationHandler() {
+  Notifications5.setNotificationHandler(null);
+}
+
+// src/runtime/response-observer.ts
+var Notifications6 = __toESM(require("expo-notifications"));
+function buildNotificationResponseKey(response) {
+  const payload = normalizeBubblesNotificationPayload(
+    getBubblesNotificationDataFromNotification(response.notification)
+  );
+  if (payload.notificationId) {
+    return `notification:${payload.notificationId}:action:${response.actionIdentifier}`;
+  }
+  return `request:${response.notification.request.identifier}:action:${response.actionIdentifier}`;
+}
+function logNotificationResponseError(description, error) {
+  console.error(
+    `[@fishonfire/bubbles-expo] Failed during notification response ${description}.`,
+    error
+  );
+}
+function buildObservedNotificationResponse(response, storedDeviceState) {
+  const payload = normalizeBubblesNotificationPayload(
+    getBubblesNotificationDataFromNotification(response.notification)
+  );
+  return {
+    notificationId: payload.notificationId,
+    event: {
+      notification: response.notification,
+      url: payload.url,
+      notificationId: payload.notificationId,
+      deviceId: storedDeviceState.deviceId,
+      data: payload.data
+    }
+  };
+}
+function postNotificationClickedDeliveryStatus(storedDeviceState, notificationId, actionId) {
+  void postStoredBubblesDeliveryStatus({
+    source: "notification response",
+    storedDeviceState,
+    notificationId,
+    status: BUBBLES_DELIVERY_STATUSES.notificationClicked,
+    actionId
+  }).catch((error) => {
+    logNotificationResponseError("delivery-status update", error);
+  });
+}
+function handleNotificationResponse(response, options, source) {
+  const storedDeviceState = readStoredDeviceState();
+  const observedResponse = buildObservedNotificationResponse(
+    response,
+    storedDeviceState
+  );
+  postNotificationClickedDeliveryStatus(
+    storedDeviceState,
+    observedResponse.notificationId,
+    response.actionIdentifier
+  );
+  options.onNotificationResponse?.(observedResponse.event);
+}
+function processStartupNotificationResponse(processNotificationResponse) {
+  try {
+    const lastResponse = Notifications6.getLastNotificationResponse();
+    if (!lastResponse) {
+      return;
+    }
+    processNotificationResponse(lastResponse);
+    Notifications6.clearLastNotificationResponse();
+  } catch (error) {
+    logNotificationResponseError("initial response handling", error);
+  }
+}
+function observeBubblesNotificationResponses(options) {
+  let lastHandledResponseKey = null;
+  const processNotificationResponse = (response) => {
+    const responseKey = buildNotificationResponseKey(response);
+    if (lastHandledResponseKey === responseKey) {
+      return;
+    }
+    lastHandledResponseKey = responseKey;
+    handleNotificationResponse(response, options, "listener");
+  };
+  processStartupNotificationResponse((response) => {
+    const responseKey = buildNotificationResponseKey(response);
+    lastHandledResponseKey = responseKey;
+    handleNotificationResponse(response, options, "startup");
+  });
+  const subscription = Notifications6.addNotificationResponseReceivedListener(
+    processNotificationResponse
+  );
+  return () => {
+    subscription.remove();
+  };
+}
+
+// src/runtime/presentation.ts
+function applyBubblesForegroundPresentation(options) {
+  applyBubblesNotificationHandler(options);
+}
+function clearBubblesForegroundPresentation() {
+  clearBubblesNotificationHandler();
+}
+function observeBubblesNotificationOpenEvents(options) {
+  return observeBubblesNotificationResponses(options);
+}
+async function prepareBubblesNotificationPresentation(options) {
+  return ensureDefaultNotificationChannel(options);
+}
+
+// src/runtime/foreground-message-observer.ts
+var import_messaging3 = require("@react-native-firebase/messaging");
+var import_react_native5 = require("react-native");
+function supportsFirebaseForegroundMessages() {
+  return import_react_native5.Platform.OS === "android" || import_react_native5.Platform.OS === "ios";
+}
+async function handleFirebaseForegroundMessage(remoteMessage) {
+  const payload = getBubblesNotificationPayloadFromRemoteMessage(remoteMessage);
+  if (!hasFirebaseDisplayNotification(remoteMessage)) {
+    return;
+  }
+  await scheduleBubblesLocalNotification({
+    source: "Firebase foreground message",
+    payload
+  });
+}
+function observeBubblesForegroundMessages() {
+  if (!supportsFirebaseForegroundMessages()) {
+    return () => {
+    };
+  }
+  const unsubscribe = (0, import_messaging3.onMessage)(
+    (0, import_messaging3.getMessaging)(),
+    (remoteMessage) => {
+      void handleFirebaseForegroundMessage(remoteMessage).catch(
+        (error) => {
+          console.error(
+            "[@fishonfire/bubbles-expo] Failed while handling a Firebase foreground message.",
+            error
+          );
+        }
+      );
+    }
+  );
+  return () => {
+    unsubscribe();
+  };
+}
+
+// src/runtime/installations.ts
+var import_installations = require("@react-native-firebase/installations");
+async function getFirebaseInstallationId(platform) {
+  try {
+    const installationsInstance = (0, import_installations.getInstallations)();
+    const installationId = await (0, import_installations.getId)(installationsInstance);
+    return getRequiredNonEmptyStringFromSource(
+      installationId,
+      `${platform} Firebase installation id from Firebase Installations`
+    );
+  } catch (error) {
+    const reason = getErrorMessage(error);
+    const platformSpecificSetupHint = platform === "ios" ? " On iOS, ensure `expo.ios.googleServicesFile` is configured and the native app has been rebuilt." : " On Android, ensure `expo.android.googleServicesFile` is configured and the native app has been rebuilt.";
+    failWithBubblesError(
+      `Failed to get a ${platform} Firebase installation id from Firebase Installations. Ensure "@react-native-firebase/app" and "@react-native-firebase/installations" are installed and Firebase is configured for this platform.${platformSpecificSetupHint} Original error: ${reason}`
+    );
+  }
+}
+
+// src/runtime/transport.ts
+function observeBubblesForegroundRemoteMessages() {
+  return observeBubblesForegroundMessages();
+}
+async function getBubblesDeviceRegistrationState(options) {
+  return getDeviceRegistrationState(options);
+}
+async function getBubblesInstallationId(platform) {
+  return getFirebaseInstallationId(platform);
+}
+
+// src/runtime/sync-device.ts
+var BubblesNotificationsSyncError = class extends Error {
+  constructor(message, snapshot, cause) {
+    super(message);
+    this.name = "BubblesNotificationsSyncError";
+    this.snapshot = snapshot;
+    this.cause = cause;
+  }
+};
+function fail2(message) {
+  throw new Error(`[@fishonfire/bubbles-expo] ${message}`);
+}
+function toError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  return new Error(String(error));
+}
+function getRequiredNonEmptyString3(value, fieldName) {
+  if (typeof value !== "string") {
+    fail2(`"${fieldName}" must be a string.`);
+  }
+  const trimmedValue = value.trim();
+  if (!trimmedValue) {
+    fail2(`"${fieldName}" must not be empty.`);
+  }
+  return trimmedValue;
+}
+function buildRuntimeSnapshot(deviceId, registrationState) {
+  return {
+    deviceId,
+    pushToken: registrationState.token,
+    tokenType: registrationState.tokenType,
+    permissionStatus: registrationState.permissionStatus,
+    notificationsEnabled: registrationState.notificationsEnabled
+  };
+}
+async function syncDeviceRegistrationState(options) {
+  const apiBaseUrl = getRequiredNonEmptyString3(options.apiBaseUrl, "apiBaseUrl");
+  const appKey = getRequiredNonEmptyString3(options.appKey, "appKey");
+  storeApiBaseUrl(apiBaseUrl);
+  storeAppKey(appKey);
+  const snapshot = buildRuntimeSnapshot(
+    options.deviceId,
+    options.registrationState
+  );
+  try {
+    const installationId = options.registrationState.notificationsEnabled ? await getBubblesInstallationId(options.registrationState.platform) : null;
+    const syncResult = await syncBubblesDevice({
+      apiBaseUrl,
+      appId: options.appId,
+      appKey,
+      userId: options.userId,
+      aliasing: options.aliasing,
+      appVersion: options.appVersion,
+      deviceId: options.deviceId,
+      platform: options.registrationState.platform,
+      pushToken: options.registrationState.token,
+      fid: installationId,
+      notificationsEnabled: options.registrationState.notificationsEnabled
+    });
+    const nextDeviceId = syncResult.deviceId ?? options.deviceId;
+    storeDeviceId(nextDeviceId);
+    return {
+      ...snapshot,
+      action: syncResult.action,
+      deviceId: nextDeviceId
+    };
+  } catch (error) {
+    const normalizedError = toError(error);
+    throw new BubblesNotificationsSyncError(
+      normalizedError.message,
+      snapshot,
+      error
+    );
+  }
+}
+async function syncExistingBubblesDevice(options) {
+  const registrationState = await getBubblesDeviceRegistrationState({
+    requestPermissions: false
+  });
+  return syncDeviceRegistrationState({
+    ...options,
+    deviceId: options.deviceId,
+    registrationState
+  });
+}
+
+// src/runtime/register-device.ts
+var DEFAULT_PERMISSION_REQUEST_OPTIONS = {
+  ios: {
+    allowAlert: true,
+    allowBadge: true,
+    allowSound: true
+  }
+};
+function buildRegistrationOptions(options) {
+  if (options?.requestPermissions === false) {
+    return {
+      requestPermissions: false,
+      permissionRequestOptions: options.permissionRequestOptions
+    };
+  }
+  return {
+    requestPermissions: options?.requestPermissions,
+    permissionRequestOptions: options?.permissionRequestOptions ?? DEFAULT_PERMISSION_REQUEST_OPTIONS
+  };
+}
+async function registerBubblesDevice(options) {
+  const registrationState = await getBubblesDeviceRegistrationState(
+    buildRegistrationOptions(options.registrationOptions)
+  );
+  return syncDeviceRegistrationState({
+    ...options,
+    deviceId: options.deviceId,
+    registrationState
+  });
+}
+
+// src/runtime/provider-operation-queue.ts
+var import_react2 = require("react");
+
+// src/runtime/provider-state.ts
+function createInitialRuntimeState(deviceId, error) {
+  return {
+    deviceId,
+    pushToken: null,
+    tokenType: null,
+    permissionStatus: "unknown",
+    notificationsEnabled: false,
+    isSyncing: false,
+    error
+  };
+}
+function normalizeProviderError(error) {
+  if (error instanceof Error) {
+    return error;
+  }
+  return new Error(String(error));
+}
+function normalizeUserId(value) {
+  if (value === null) {
+    return null;
+  }
+  const trimmedValue = value.trim();
+  return trimmedValue.length > 0 ? trimmedValue : null;
+}
+function getAutomaticSyncSignature(input) {
+  return JSON.stringify({
+    appId: input.appId,
+    appKey: input.appKey,
+    apiBaseUrl: input.apiBaseUrl,
+    userId: input.userId,
+    aliasing: input.aliasing ?? [],
+    appVersion: input.appVersion ?? null,
+    deviceId: input.deviceId
+  });
+}
+function getRuntimeStateUpdate(snapshot) {
+  return {
+    deviceId: snapshot.deviceId,
+    pushToken: snapshot.pushToken,
+    tokenType: snapshot.tokenType,
+    permissionStatus: snapshot.permissionStatus,
+    notificationsEnabled: snapshot.notificationsEnabled
+  };
+}
+function getInitialRuntimeState() {
+  try {
+    return createInitialRuntimeState(readStoredDeviceId(), null);
+  } catch (error) {
+    return createInitialRuntimeState(
+      null,
+      normalizeProviderError(error)
+    );
+  }
+}
+
+// src/runtime/provider-operation-queue.ts
+function useBubblesRuntimeOperationQueue(setState) {
+  const isMountedRef = (0, import_react2.useRef)(true);
+  const pendingOperationsRef = (0, import_react2.useRef)(0);
+  const operationQueueRef = (0, import_react2.useRef)(Promise.resolve());
+  const enqueueOperation = (0, import_react2.useCallback)((operation) => {
+    pendingOperationsRef.current += 1;
+    setState((currentState) => ({
+      ...currentState,
+      isSyncing: true,
+      error: null
+    }));
+    const queuedOperation = operationQueueRef.current.catch(() => void 0).then(operation);
+    operationQueueRef.current = queuedOperation.then(
+      () => void 0,
+      () => void 0
+    );
+    return queuedOperation.then(
+      (result) => {
+        pendingOperationsRef.current -= 1;
+        if (!isMountedRef.current) {
+          return;
+        }
+        setState((currentState) => ({
+          ...currentState,
+          ...result ?? {},
+          isSyncing: pendingOperationsRef.current > 0,
+          error: null
+        }));
+      },
+      (error) => {
+        pendingOperationsRef.current -= 1;
+        const normalizedError = normalizeProviderError(error);
+        const snapshot = error instanceof BubblesNotificationsSyncError ? error.snapshot : void 0;
+        if (isMountedRef.current) {
+          setState((currentState) => ({
+            ...currentState,
+            ...snapshot ? getRuntimeStateUpdate(snapshot) : {},
+            isSyncing: pendingOperationsRef.current > 0,
+            error: normalizedError
+          }));
+        }
+        throw normalizedError;
+      }
+    );
+  }, [setState]);
+  return {
+    enqueueOperation,
+    isMountedRef
+  };
+}
+
+// src/runtime/BubblesNotificationsProvider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function BubblesNotificationsProvider(props) {
+  const {
+    appId,
+    appKey,
+    apiBaseUrl,
+    ready,
+    userId,
+    aliasing,
+    appVersion,
+    onLogout,
+    foregroundPresentation,
+    onNotificationResponse,
+    children
+  } = props;
+  const normalizedUserId = normalizeUserId(userId);
+  const [state, setState] = (0, import_react3.useState)(getInitialRuntimeState);
+  const { enqueueOperation, isMountedRef } = useBubblesRuntimeOperationQueue(setState);
+  const lastAutomaticSyncSignatureRef = (0, import_react3.useRef)(null);
+  const previousUserIdRef = (0, import_react3.useRef)(normalizedUserId);
+  const buildAutomaticSyncSignature = (0, import_react3.useCallback)((deviceId) => {
+    return getAutomaticSyncSignature({
+      appId,
+      appKey,
+      apiBaseUrl,
+      userId: normalizedUserId,
+      aliasing,
+      appVersion,
+      deviceId
+    });
+  }, [
+    appId,
+    appKey,
+    apiBaseUrl,
+    normalizedUserId,
+    aliasing,
+    appVersion
+  ]);
+  (0, import_react3.useEffect)(() => {
+    return () => {
+      isMountedRef.current = false;
+      clearBubblesForegroundPresentation();
+    };
+  }, [isMountedRef]);
+  (0, import_react3.useEffect)(() => {
+    let isCancelled = false;
+    void (async () => {
+      try {
+        storeApiBaseUrl(getRequiredNonEmptyString(apiBaseUrl, "apiBaseUrl"));
+        storeAppKey(getRequiredNonEmptyString(appKey, "appKey"));
+        await prepareBubblesNotificationPresentation();
+      } catch (error) {
+        if (!isCancelled && isMountedRef.current) {
+          setState((currentState) => ({
+            ...currentState,
+            error: normalizeProviderError(error)
+          }));
+        }
+      }
+    })();
+    return () => {
+      isCancelled = true;
+    };
+  }, [apiBaseUrl, appKey, isMountedRef]);
+  (0, import_react3.useEffect)(() => {
+    applyBubblesForegroundPresentation(foregroundPresentation);
+  }, [foregroundPresentation]);
+  (0, import_react3.useEffect)(() => {
+    return observeBubblesForegroundRemoteMessages();
+  }, []);
+  (0, import_react3.useEffect)(() => {
+    return observeBubblesNotificationOpenEvents({
+      onNotificationResponse
+    });
+  }, [onNotificationResponse]);
+  (0, import_react3.useEffect)(() => {
+    const previousUserId = previousUserIdRef.current;
+    if (previousUserId !== null && normalizedUserId === null) {
+      lastAutomaticSyncSignatureRef.current = null;
+      if (onLogout) {
+        void enqueueOperation(async () => {
+          await onLogout({
+            previousUserId,
+            deviceId: state.deviceId
+          });
+        });
+      }
+    }
+    previousUserIdRef.current = normalizedUserId;
+  }, [enqueueOperation, normalizedUserId, onLogout, state.deviceId]);
+  (0, import_react3.useEffect)(() => {
+    if (!ready || normalizedUserId === null || state.deviceId === null) {
+      lastAutomaticSyncSignatureRef.current = null;
+      return;
+    }
+    const syncSignature = buildAutomaticSyncSignature(state.deviceId);
+    if (lastAutomaticSyncSignatureRef.current === syncSignature) {
+      return;
+    }
+    lastAutomaticSyncSignatureRef.current = syncSignature;
+    const storedDeviceId = state.deviceId;
+    void enqueueOperation(async () => {
+      const result = await syncExistingBubblesDevice({
+        appId,
+        appKey,
+        apiBaseUrl,
+        userId: normalizedUserId,
+        aliasing,
+        appVersion,
+        deviceId: storedDeviceId
+      });
+      return getRuntimeStateUpdate(result);
+    });
+  }, [
+    ready,
+    normalizedUserId,
+    state.deviceId,
+    appId,
+    appKey,
+    apiBaseUrl,
+    aliasing,
+    appVersion,
+    buildAutomaticSyncSignature,
+    enqueueOperation
+  ]);
+  function registerDevice(options) {
+    return enqueueOperation(async () => {
+      if (!ready) {
+        failWithBubblesError(
+          '"registerDevice()" requires "ready" to be true before the device can be synced.'
+        );
+      }
+      if (normalizedUserId === null) {
+        failWithBubblesError(
+          '"registerDevice()" requires a non-null "userId" before the device can be synced.'
+        );
+      }
+      const result = await registerBubblesDevice({
+        appId,
+        appKey,
+        apiBaseUrl,
+        userId: normalizedUserId,
+        aliasing,
+        appVersion,
+        deviceId: state.deviceId,
+        registrationOptions: options
+      });
+      if (result.deviceId !== null) {
+        lastAutomaticSyncSignatureRef.current = buildAutomaticSyncSignature(
+          result.deviceId
+        );
+      }
+      return getRuntimeStateUpdate(result);
+    });
+  }
+  const contextValue = {
+    registerDevice,
+    deviceId: state.deviceId,
+    pushToken: state.pushToken,
+    tokenType: state.tokenType,
+    permissionStatus: state.permissionStatus,
+    notificationsEnabled: state.notificationsEnabled,
+    isSyncing: state.isSyncing,
+    error: state.error
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(BubblesNotificationsContext.Provider, { value: contextValue, children });
+}
+
+// src/runtime/useBubblesNotifications.ts
+var import_react4 = require("react");
+function fail3(message) {
+  throw new Error(`[@fishonfire/bubbles-expo] ${message}`);
+}
+function useBubblesNotifications() {
+  const context = (0, import_react4.useContext)(BubblesNotificationsContext);
+  if (context === null) {
+    fail3(
+      '"useBubblesNotifications()" must be used inside "BubblesNotificationsProvider".'
+    );
+  }
+  return context;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ANDROID_CHANNEL_IMPORTANCE_VALUES,
+  BUBBLES_DELIVERY_STATUSES,
+  BUBBLES_NOTIFICATIONS_EXPO_EXTRA_KEY,
+  BubblesAppAuthenticationError,
+  BubblesNotificationsProvider,
+  buildBubblesDeliveryStatusPayload,
+  buildCreateDevicePayload,
+  buildStoredDeliveryStatusEventKey,
+  buildUpdateDevicePayload,
+  createBubblesDevice,
+  createBubblesDeviceClient,
+  createStoredDeliveryStatusEvent,
+  describeNotificationPermissionStatus,
+  enqueueStoredDeliveryStatusEvent,
+  ensureDefaultNotificationChannel,
+  ensureNotificationPermissions,
+  extractDeviceIdFromDeviceResponse,
+  flushStoredBubblesDeliveryStatuses,
+  getAndroidNotificationChannelImportance,
+  getBubblesNotificationsRuntimeConfig,
+  getDefaultNotificationChannelConfig,
+  getDeviceRegistrationState,
+  getDeviceToken,
+  getFCMToken,
+  getNotificationPermissions,
+  isNotificationPermissionGranted,
+  markStoredDeliveryStatusEventPosted,
+  patchStoredDeviceState,
+  postBubblesDeliveryStatus,
+  postStoredBubblesDeliveryStatus,
+  readStoredApiBaseUrl,
+  readStoredAppKey,
+  readStoredDeliveryStatusLedger,
+  readStoredDeviceId,
+  readStoredDeviceState,
+  registerBubblesBackgroundHandlers,
+  storeApiBaseUrl,
+  storeAppKey,
+  storeDeliveryStatusLedger,
+  storeDeviceId,
+  storeDeviceState,
+  syncBubblesDevice,
+  updateBubblesDevice,
+  useBubblesNotifications
+});