@damn-coding/geopulse-react-native 0.0.0-stage → 0.5.1

package/dist/index.js

@@ -0,0 +1,1764 @@
+"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, {
+  AlertExperience: () => AlertExperience,
+  ApplicationMismatchError: () => ApplicationMismatchError,
+  BannerExperience: () => BannerExperience,
+  CardExperience: () => CardExperience,
+  DeviceLocationProvider: () => DeviceLocationProvider,
+  ExperienceView: () => ExperienceView,
+  ExpoPermissionProvider: () => ExpoPermissionProvider,
+  GeoPulse: () => GeoPulse,
+  GeoPulseSdk: () => GeoPulseSdk,
+  ManualNetworkMonitor: () => ManualNetworkMonitor,
+  MessageExperience: () => MessageExperience,
+  NetInfoNetworkMonitor: () => NetInfoNetworkMonitor,
+  SimulatedLocationProvider: () => SimulatedLocationProvider,
+  SimulatedPermissionProvider: () => SimulatedPermissionProvider,
+  isAlertExperience: () => isAlertExperience
+});
+module.exports = __toCommonJS(index_exports);
+var import_react_native2 = require("react-native");
+
+// src/config/async-storage-key-value-store.ts
+var import_async_storage = __toESM(require("@react-native-async-storage/async-storage"));
+var AsyncStorageKeyValueStore = class {
+  async getItem(key) {
+    return import_async_storage.default.getItem(key);
+  }
+  async setItem(key, value) {
+    await import_async_storage.default.setItem(key, value);
+  }
+};
+
+// src/config/types.ts
+var DEFAULT_BACKEND_URL = "https://api.damncoding.com";
+var SDK_VERSION = "0.5.1";
+
+// src/config/key-value-store.ts
+var InMemoryKeyValueStore = class {
+  data = /* @__PURE__ */ new Map();
+  async getItem(key) {
+    return this.data.get(key) ?? null;
+  }
+  async setItem(key, value) {
+    this.data.set(key, value);
+  }
+};
+
+// src/events/uuid.ts
+function generateEventId() {
+  const bytes = new Uint8Array(16);
+  const cryptoApi = globalThis.crypto;
+  if (cryptoApi?.getRandomValues) {
+    cryptoApi.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < bytes.length; i++) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  bytes[6] = (bytes[6] ?? 0) & 15 | 64;
+  bytes[8] = (bytes[8] ?? 0) & 63 | 128;
+  const hex = [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+// src/config/device-id.ts
+var DEVICE_ID_STORAGE_KEY = "@geopulse/device-id";
+async function getOrCreateDeviceId(store) {
+  const existing = await store.getItem(DEVICE_ID_STORAGE_KEY);
+  if (existing) {
+    return existing;
+  }
+  const deviceId = generateEventId();
+  await store.setItem(DEVICE_ID_STORAGE_KEY, deviceId);
+  return deviceId;
+}
+
+// src/config/config-cache.ts
+var CONFIG_CACHE_STORAGE_KEY = "@geopulse/config-cache";
+var ConfigCache = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  async save(config) {
+    const cached = { config, fetchedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await this.store.setItem(CONFIG_CACHE_STORAGE_KEY, JSON.stringify(cached));
+  }
+  async load() {
+    const raw = await this.store.getItem(CONFIG_CACHE_STORAGE_KEY);
+    if (!raw) return null;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/protocol.ts
+var SDK_KEY_HEADER = "x-geopulse-sdk-key";
+var APPLICATION_ID_HEADER = "x-geopulse-application-id";
+var SDK_ENDPOINTS = {
+  GET_PROJECT_CONFIG: "getProjectConfig",
+  INGEST_LOCATION_EVENT: "ingestLocationEvent",
+  GET_PENDING_EXPERIENCES: "getPendingExperiences",
+  ACKNOWLEDGE_EXPERIENCE_DELIVERY: "acknowledgeExperienceDelivery"
+};
+var EARTH_RADIUS_METERS = 6371e3;
+function toRadians(degrees) {
+  return degrees * Math.PI / 180;
+}
+function calculateDistanceMeters(from, to) {
+  const lat1 = toRadians(from.latitude);
+  const lat2 = toRadians(to.latitude);
+  const deltaLat = toRadians(to.latitude - from.latitude);
+  const deltaLng = toRadians(to.longitude - from.longitude);
+  const a = Math.sin(deltaLat / 2) ** 2 + Math.cos(lat1) * Math.cos(lat2) * Math.sin(deltaLng / 2) ** 2;
+  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+  return EARTH_RADIUS_METERS * c;
+}
+var ANCHOR_POINTS = [
+  "top-left",
+  "top-center",
+  "top-right",
+  "center-left",
+  "center",
+  "center-right",
+  "bottom-left",
+  "bottom-center",
+  "bottom-right"
+];
+function isLegacyExperienceStyle(style) {
+  return !("version" in style);
+}
+var HEX_COLOR_PATTERN = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
+var OFFSET_LIMIT = 500;
+var ANCHOR_BASE_POSITIONS = {
+  "top-left": { top: 0, left: 0, bottom: null, right: null },
+  "top-center": { top: 0, left: null, bottom: null, right: null },
+  "top-right": { top: 0, left: null, bottom: null, right: 0 },
+  "center-left": { top: null, left: 0, bottom: null, right: null },
+  center: { top: null, left: null, bottom: null, right: null },
+  "center-right": { top: null, left: null, bottom: null, right: 0 },
+  "bottom-left": { top: null, left: 0, bottom: 0, right: null },
+  "bottom-center": { top: null, left: null, bottom: 0, right: null },
+  "bottom-right": { top: null, left: null, bottom: 0, right: 0 }
+};
+var DEFAULT_STYLES = {
+  card: {
+    container: { backgroundColor: "#ffffff", borderColor: null, borderWidth: 0, borderRadius: 16, padding: 20, backgroundImageUrl: null, backgroundImageFit: "cover", width: "fill", height: "auto" },
+    title: { visible: true, color: "#111827", fontSize: 18, fontWeight: "bold" },
+    body: { visible: true, color: "#374151", fontSize: 14, fontWeight: "normal" },
+    button: { visible: true, backgroundColor: "#2563eb", textColor: "#ffffff", borderRadius: 8, position: { top: null, bottom: 16, left: 16, right: null } }
+  },
+  banner: {
+    container: { backgroundColor: "#111827", borderColor: null, borderWidth: 0, borderRadius: 0, padding: 12, backgroundImageUrl: null, backgroundImageFit: "cover", width: "fill", height: "auto" },
+    title: { visible: true, color: "#ffffff", fontSize: 15, fontWeight: "bold" },
+    body: { visible: true, color: "#e5e7eb", fontSize: 13, fontWeight: "normal" },
+    button: { visible: false, backgroundColor: "#2563eb", textColor: "#ffffff", borderRadius: 6, position: { top: null, bottom: null, left: null, right: 12 } }
+  },
+  alert: {
+    container: { backgroundColor: "#ffffff", borderColor: null, borderWidth: 0, borderRadius: 16, padding: 24, backgroundImageUrl: null, backgroundImageFit: "cover", width: "fill", height: "auto" },
+    title: { visible: true, color: "#111827", fontSize: 18, fontWeight: "bold" },
+    body: { visible: true, color: "#374151", fontSize: 14, fontWeight: "normal" },
+    button: { visible: true, backgroundColor: "#2563eb", textColor: "#ffffff", borderRadius: 8, position: { top: null, bottom: 16, left: null, right: 16 } }
+  },
+  message: {
+    container: { backgroundColor: "#1f2937", borderColor: null, borderWidth: 0, borderRadius: 12, padding: 16, backgroundImageUrl: null, backgroundImageFit: "cover", width: "fill", height: "auto" },
+    title: { visible: false, color: "#ffffff", fontSize: 16, fontWeight: "bold" },
+    body: { visible: true, color: "#ffffff", fontSize: 14, fontWeight: "normal" },
+    button: { visible: false, backgroundColor: "#2563eb", textColor: "#ffffff", borderRadius: 8, position: { top: null, bottom: 16, left: null, right: 16 } }
+  }
+};
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function resolveColor(value, fallback) {
+  return typeof value === "string" && HEX_COLOR_PATTERN.test(value) ? value : fallback;
+}
+function resolveOptionalColor(value, fallback) {
+  return typeof value === "string" && HEX_COLOR_PATTERN.test(value) ? value : fallback;
+}
+function resolveNonNegativeNumber(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function resolvePosition(position, fallback) {
+  if (!position || !ANCHOR_POINTS.includes(position.anchor)) return fallback;
+  const offsetX = typeof position.offsetX === "number" && Number.isFinite(position.offsetX) ? clamp(position.offsetX, -OFFSET_LIMIT, OFFSET_LIMIT) : 0;
+  const offsetY = typeof position.offsetY === "number" && Number.isFinite(position.offsetY) ? clamp(position.offsetY, -OFFSET_LIMIT, OFFSET_LIMIT) : 0;
+  const base = ANCHOR_BASE_POSITIONS[position.anchor];
+  return {
+    top: base.top === null ? null : base.top + offsetY,
+    bottom: base.bottom === null ? null : base.bottom + offsetY,
+    left: base.left === null ? null : base.left + offsetX,
+    right: base.right === null ? null : base.right + offsetX
+  };
+}
+function resolveWidth(mode, value, fallback) {
+  if (mode === "fixed") {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+  }
+  if (mode === "fill") return "fill";
+  return fallback;
+}
+function resolveHeight(mode, value, fallback) {
+  if (mode === "fixed") {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+  }
+  if (mode === "auto") return "auto";
+  return fallback;
+}
+function resolveContainer(custom, fallback) {
+  return {
+    backgroundColor: resolveColor(custom?.backgroundColor, fallback.backgroundColor),
+    borderColor: resolveOptionalColor(custom?.borderColor, fallback.borderColor),
+    borderWidth: resolveNonNegativeNumber(custom?.borderWidth, fallback.borderWidth),
+    borderRadius: resolveNonNegativeNumber(custom?.borderRadius, fallback.borderRadius),
+    padding: resolveNonNegativeNumber(custom?.padding, fallback.padding),
+    backgroundImageUrl: typeof custom?.backgroundImageUrl === "string" && custom.backgroundImageUrl.length > 0 ? custom.backgroundImageUrl : fallback.backgroundImageUrl,
+    backgroundImageFit: custom?.backgroundImageFit ?? fallback.backgroundImageFit,
+    width: resolveWidth(custom?.widthMode, custom?.width, fallback.width),
+    height: resolveHeight(custom?.heightMode, custom?.height, fallback.height)
+  };
+}
+function resolveText(custom, fallback) {
+  return {
+    visible: custom?.visible ?? fallback.visible,
+    color: resolveColor(custom?.color, fallback.color),
+    fontSize: resolveNonNegativeNumber(custom?.fontSize, fallback.fontSize),
+    fontWeight: custom?.fontWeight ?? fallback.fontWeight
+  };
+}
+function resolveButton(custom, fallback) {
+  return {
+    visible: custom?.visible ?? fallback.visible,
+    backgroundColor: resolveColor(custom?.backgroundColor, fallback.backgroundColor),
+    textColor: resolveColor(custom?.textColor, fallback.textColor),
+    borderRadius: resolveNonNegativeNumber(custom?.borderRadius, fallback.borderRadius),
+    position: resolvePosition(custom?.position, fallback.position)
+  };
+}
+function upgradeLegacyStyle(legacy) {
+  return {
+    version: 2,
+    container: { backgroundColor: legacy.backgroundColor },
+    title: { color: legacy.textColor },
+    body: { color: legacy.textColor },
+    button: { backgroundColor: legacy.accentColor }
+  };
+}
+function resolveExperienceStyle(type, custom) {
+  const fallback = DEFAULT_STYLES[type] ?? DEFAULT_STYLES.card;
+  if (!custom) return fallback;
+  const v2 = isLegacyExperienceStyle(custom) ? upgradeLegacyStyle(custom) : custom;
+  return {
+    container: resolveContainer(v2.container, fallback.container),
+    title: resolveText(v2.title, fallback.title),
+    body: resolveText(v2.body, fallback.body),
+    button: resolveButton(v2.button, fallback.button)
+  };
+}
+
+// src/firebase/api-client.ts
+var MAX_RETRY_AFTER_MS = 15 * 6e4;
+var ApiError = class extends Error {
+  constructor(message, status, retryAfterMs = null) {
+    super(message);
+    this.status = status;
+    this.retryAfterMs = retryAfterMs;
+    this.name = "ApiError";
+  }
+  status;
+  retryAfterMs;
+};
+function retryAfterMsFrom(response) {
+  const seconds = Number(response.headers?.get?.("retry-after"));
+  return Number.isFinite(seconds) && seconds > 0 ? Math.min(seconds * 1e3, MAX_RETRY_AFTER_MS) : null;
+}
+function failure(callName, response) {
+  return new ApiError(`${callName} failed with status ${response.status}`, response.status, response.status === 429 ? retryAfterMsFrom(response) : null);
+}
+var REQUEST_TIMEOUT_MS = 15e3;
+async function fetchWithTimeout(url, init) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function fetchOrThrow(callName, url, init) {
+  try {
+    return await fetchWithTimeout(url, init);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`${callName} request failed: ${message}`);
+  }
+}
+var ApiClient = class {
+  constructor(baseUrl, sdkKey, applicationId) {
+    this.baseUrl = baseUrl;
+    this.sdkKey = sdkKey;
+    this.applicationId = applicationId;
+  }
+  baseUrl;
+  sdkKey;
+  applicationId;
+  headers(json = false) {
+    return {
+      [SDK_KEY_HEADER]: this.sdkKey,
+      ...this.applicationId ? { [APPLICATION_ID_HEADER]: this.applicationId } : {},
+      ...json ? { "Content-Type": "application/json" } : {}
+    };
+  }
+  /**
+   * `identity` doubles as this device's registration/heartbeat (see
+   * functions/src/events/get-project-config.ts) — sent as query params
+   * since GET requests carry no body.
+   */
+  async getProjectConfig(identity) {
+    const query = new URLSearchParams({
+      deviceId: identity.deviceId,
+      platform: identity.platform,
+      sdkVersion: identity.sdkVersion
+    });
+    const response = await fetchOrThrow("getProjectConfig", `${this.baseUrl}/${SDK_ENDPOINTS.GET_PROJECT_CONFIG}?${query.toString()}`, {
+      method: "GET",
+      headers: this.headers()
+    });
+    if (!response.ok) {
+      throw failure("getProjectConfig", response);
+    }
+    return await response.json();
+  }
+  async ingestEvent(payload) {
+    const response = await fetchOrThrow("ingestLocationEvent", `${this.baseUrl}/${SDK_ENDPOINTS.INGEST_LOCATION_EVENT}`, {
+      method: "POST",
+      headers: this.headers(true),
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      throw failure("ingestLocationEvent", response);
+    }
+    return await response.json();
+  }
+  /** Polled by GeoPulseSdk's experience-polling loop — see core/geo-pulse-sdk.ts. */
+  async getPendingExperiences(deviceId) {
+    const query = new URLSearchParams({ deviceId });
+    const response = await fetchOrThrow("getPendingExperiences", `${this.baseUrl}/${SDK_ENDPOINTS.GET_PENDING_EXPERIENCES}?${query.toString()}`, {
+      method: "GET",
+      headers: this.headers()
+    });
+    if (!response.ok) {
+      throw failure("getPendingExperiences", response);
+    }
+    const body = await response.json();
+    return { experiences: body.experiences ?? [], revoked: body.revoked ?? [] };
+  }
+  /** Confirms a delivery was surfaced via `experience.received`, so it stops appearing in future polls. */
+  async acknowledgeExperienceDelivery(deliveryId) {
+    const response = await fetchOrThrow("acknowledgeExperienceDelivery", `${this.baseUrl}/${SDK_ENDPOINTS.ACKNOWLEDGE_EXPERIENCE_DELIVERY}`, {
+      method: "POST",
+      headers: this.headers(true),
+      body: JSON.stringify({ deliveryId })
+    });
+    if (!response.ok) {
+      throw failure("acknowledgeExperienceDelivery", response);
+    }
+  }
+};
+
+// src/events/factory.ts
+function createEventPayload(params) {
+  return {
+    id: generateEventId(),
+    type: params.type,
+    projectId: params.projectId,
+    applicationId: params.applicationId,
+    geofenceId: params.geofence.id,
+    locationId: params.geofence.locationId,
+    deviceId: params.deviceId,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    latitude: params.location.latitude,
+    longitude: params.location.longitude,
+    metadata: params.metadata ?? {},
+    sdkVersion: SDK_VERSION,
+    // First-try attempt count; SyncManager overwrites this with the real
+    // count if the event ends up going through the retry queue (see
+    // sync/sync-manager.ts#retryPending) — that's what makes the
+    // "Attempts" column in the admin's Event Explorer meaningful.
+    attempts: 1
+  };
+}
+
+// src/geofencing/state-machine.ts
+var DEFAULT_EXIT_BUFFER_METERS = 20;
+var DEFAULT_MAX_ACCURACY_METERS = 100;
+var DEFAULT_TRANSITION_COOLDOWN_MS = 2 * 6e4;
+var GeofenceStateMachine = class {
+  membershipByGeofenceId = /* @__PURE__ */ new Map();
+  lastTransitionAtByGeofenceId = /* @__PURE__ */ new Map();
+  exitBufferMeters;
+  maxAccuracyMeters;
+  cooldownMs;
+  now;
+  constructor(options = {}) {
+    this.exitBufferMeters = options.exitBufferMeters ?? DEFAULT_EXIT_BUFFER_METERS;
+    this.maxAccuracyMeters = options.maxAccuracyMeters ?? DEFAULT_MAX_ACCURACY_METERS;
+    this.cooldownMs = options.cooldownMs ?? DEFAULT_TRANSITION_COOLDOWN_MS;
+    this.now = options.now ?? Date.now;
+  }
+  evaluate(location, geofences) {
+    if (location.accuracy !== void 0 && location.accuracy > this.maxAccuracyMeters) {
+      return [];
+    }
+    const transitions = [];
+    const activeIds = /* @__PURE__ */ new Set();
+    const exitBuffer = Math.max(this.exitBufferMeters, location.accuracy ?? 0);
+    const now = this.now();
+    for (const geofence of geofences) {
+      activeIds.add(geofence.id);
+      const distance = calculateDistanceMeters(location, geofence.center);
+      const previousMembership = this.membershipByGeofenceId.get(geofence.id) ?? "OUTSIDE";
+      const nextMembership = previousMembership === "INSIDE" ? distance > geofence.radiusMeters + exitBuffer ? "OUTSIDE" : "INSIDE" : distance <= geofence.radiusMeters ? "INSIDE" : "OUTSIDE";
+      if (previousMembership === nextMembership) {
+        this.membershipByGeofenceId.set(geofence.id, nextMembership);
+        continue;
+      }
+      const lastTransitionAt = this.lastTransitionAtByGeofenceId.get(geofence.id);
+      if (lastTransitionAt !== void 0 && now - lastTransitionAt < this.cooldownMs) {
+        this.membershipByGeofenceId.set(geofence.id, previousMembership);
+        continue;
+      }
+      this.membershipByGeofenceId.set(geofence.id, nextMembership);
+      this.lastTransitionAtByGeofenceId.set(geofence.id, now);
+      transitions.push({ geofence, type: nextMembership === "INSIDE" ? "geofence.enter" : "geofence.exit" });
+    }
+    for (const id of [...this.membershipByGeofenceId.keys()]) {
+      if (!activeIds.has(id)) {
+        this.membershipByGeofenceId.delete(id);
+        this.lastTransitionAtByGeofenceId.delete(id);
+      }
+    }
+    return transitions;
+  }
+  getMembership(geofenceId) {
+    return this.membershipByGeofenceId.get(geofenceId) ?? "OUTSIDE";
+  }
+  isInsideAny() {
+    for (const membership of this.membershipByGeofenceId.values()) {
+      if (membership === "INSIDE") return true;
+    }
+    return false;
+  }
+  exportState() {
+    return {
+      membership: Object.fromEntries(this.membershipByGeofenceId),
+      lastTransitionAt: Object.fromEntries(this.lastTransitionAtByGeofenceId)
+    };
+  }
+  /** Only for a machine that has not evaluated anything yet. */
+  restoreState(state) {
+    this.membershipByGeofenceId.clear();
+    this.lastTransitionAtByGeofenceId.clear();
+    for (const [id, membership] of Object.entries(state.membership)) {
+      if (membership === "INSIDE" || membership === "OUTSIDE") this.membershipByGeofenceId.set(id, membership);
+    }
+    for (const [id, at] of Object.entries(state.lastTransitionAt)) {
+      if (typeof at === "number" && Number.isFinite(at)) this.lastTransitionAtByGeofenceId.set(id, at);
+    }
+  }
+  reset() {
+    this.membershipByGeofenceId.clear();
+    this.lastTransitionAtByGeofenceId.clear();
+  }
+};
+
+// src/geofencing/state-store.ts
+var STORAGE_KEY = "@geopulse/geofence-state";
+var GEOFENCE_STATE_MAX_AGE_MS = 12 * 60 * 60 * 1e3;
+var GeofenceStateStore = class {
+  constructor(store, now = Date.now) {
+    this.store = store;
+    this.now = now;
+  }
+  store;
+  now;
+  async load() {
+    try {
+      const raw = await this.store.getItem(STORAGE_KEY);
+      if (!raw) return null;
+      const saved = JSON.parse(raw);
+      if (typeof saved.savedAt !== "number" || this.now() - saved.savedAt > GEOFENCE_STATE_MAX_AGE_MS) return null;
+      if (typeof saved.membership !== "object" || saved.membership === null) return null;
+      return { membership: saved.membership, lastTransitionAt: saved.lastTransitionAt ?? {} };
+    } catch {
+      return null;
+    }
+  }
+  async save(state) {
+    try {
+      await this.store.setItem(STORAGE_KEY, JSON.stringify({ ...state, savedAt: this.now() }));
+    } catch {
+    }
+  }
+};
+
+// src/location/simulated-location-provider.ts
+var SimulatedLocationProvider = class {
+  onUpdate = null;
+  currentLocation = null;
+  start(onUpdate) {
+    this.onUpdate = onUpdate;
+    if (this.currentLocation) {
+      onUpdate(this.currentLocation);
+    }
+  }
+  stop() {
+    this.onUpdate = null;
+  }
+  setLocation(coords) {
+    const location = { ...coords, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+    this.currentLocation = location;
+    this.onUpdate?.(location);
+  }
+  getCurrentLocation() {
+    return this.currentLocation;
+  }
+};
+
+// src/permissions/simulated-permission-provider.ts
+var SimulatedPermissionProvider = class {
+  async getStatus() {
+    return "granted";
+  }
+  async request() {
+    return "granted";
+  }
+};
+
+// src/sync/retry-policy.ts
+var RETRY_POLICY = {
+  /** Attempts beyond this stop increasing the delay — it plateaus at MAX_RETRY_DELAY_MS, but retrying never stops entirely (the SDK must never give up on an event; see storage/queue.ts). */
+  MAX_RETRIES: 6,
+  BASE_RETRY_DELAY_MS: 5e3,
+  MAX_RETRY_DELAY_MS: 5 * 6e4
+};
+function computeRetryDelayMs(attempts) {
+  const cappedAttempts = Math.min(attempts, RETRY_POLICY.MAX_RETRIES);
+  const exponential = RETRY_POLICY.BASE_RETRY_DELAY_MS * 2 ** Math.max(0, cappedAttempts - 1);
+  const delay = Math.min(exponential, RETRY_POLICY.MAX_RETRY_DELAY_MS);
+  const jitter = delay * 0.2 * (Math.random() * 2 - 1);
+  return Math.round(delay + jitter);
+}
+
+// src/storage/memory-store.ts
+var InMemoryEventQueueStore = class {
+  eventsById = /* @__PURE__ */ new Map();
+  async getAll() {
+    return [...this.eventsById.values()];
+  }
+  async save(event) {
+    this.eventsById.set(event.eventId, event);
+  }
+  async remove(eventId) {
+    this.eventsById.delete(eventId);
+  }
+};
+
+// src/storage/queue.ts
+var MAX_QUEUE_SIZE = 100;
+var MAX_QUEUED_EVENT_AGE_MS = 24 * 60 * 60 * 1e3;
+var PendingEventQueue = class {
+  constructor(store = new InMemoryEventQueueStore()) {
+    this.store = store;
+  }
+  store;
+  chain = Promise.resolve();
+  serialized(operation) {
+    const result = this.chain.then(operation, operation);
+    this.chain = result.catch(() => void 0);
+    return result;
+  }
+  enqueue(payload) {
+    return this.serialized(async () => {
+      await this.store.save({
+        eventId: payload.id,
+        type: payload.type,
+        applicationId: payload.applicationId,
+        deviceId: payload.deviceId,
+        locationId: payload.locationId,
+        geofenceId: payload.geofenceId,
+        timestamp: payload.timestamp,
+        payload,
+        attempts: 0,
+        status: "pending",
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        lastAttemptAt: null,
+        nextAttemptAt: null
+      });
+      await this.trim();
+    });
+  }
+  /** Every queued event, regardless of retry timing — used for diagnostics/pending counts. */
+  listPending() {
+    return this.serialized(() => this.store.getAll());
+  }
+  /** Only events whose backoff window has elapsed (or that have never been attempted) — used by SyncManager.retryPending(). Drops events too old to ever be accepted. */
+  listReadyForRetry(now = /* @__PURE__ */ new Date()) {
+    return this.serialized(async () => {
+      let all = await this.store.getAll();
+      for (const event of all.filter((candidate) => isTooOld(candidate, now.getTime()))) {
+        await this.store.remove(event.eventId);
+      }
+      all = all.filter((event) => !isTooOld(event, now.getTime()));
+      return all.filter((event) => event.status !== "sending" && (!event.nextAttemptAt || new Date(event.nextAttemptAt) <= now));
+    });
+  }
+  /** Marks an event as in-flight so a concurrent retry pass won't also pick it up. */
+  markSending(eventId) {
+    return this.serialized(async () => {
+      const existing = await this.get(eventId);
+      if (!existing) return;
+      await this.store.save({ ...existing, status: "sending" });
+    });
+  }
+  /** `minDelayMs` lets a 429's Retry-After push the next attempt later than the normal backoff. */
+  markAttemptFailed(eventId, minDelayMs = 0) {
+    return this.serialized(async () => {
+      const existing = await this.get(eventId);
+      if (!existing) return;
+      const attempts = existing.attempts + 1;
+      const now = /* @__PURE__ */ new Date();
+      await this.store.save({
+        ...existing,
+        status: "failed",
+        attempts,
+        lastAttemptAt: now.toISOString(),
+        nextAttemptAt: new Date(now.getTime() + Math.max(computeRetryDelayMs(attempts), minDelayMs)).toISOString()
+      });
+    });
+  }
+  markSent(eventId) {
+    return this.serialized(() => this.store.remove(eventId));
+  }
+  async get(eventId) {
+    return (await this.store.getAll()).find((event) => event.eventId === eventId);
+  }
+  /** Keeps the queue within MAX_QUEUE_SIZE by dropping the oldest events that are not being sent right now. */
+  async trim() {
+    const all = await this.store.getAll();
+    if (all.length <= MAX_QUEUE_SIZE) return;
+    const droppable = all.filter((event) => event.status !== "sending").sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
+    for (const event of droppable.slice(0, all.length - MAX_QUEUE_SIZE)) {
+      await this.store.remove(event.eventId);
+    }
+  }
+};
+function isTooOld(event, nowMs) {
+  const eventTime = Date.parse(event.timestamp);
+  return !Number.isNaN(eventTime) && nowMs - eventTime > MAX_QUEUED_EVENT_AGE_MS;
+}
+
+// src/sync/network-monitor.ts
+var ManualNetworkMonitor = class {
+  status = "online";
+  listeners = /* @__PURE__ */ new Set();
+  getStatus() {
+    return this.status;
+  }
+  setStatus(status) {
+    if (status === this.status) return;
+    this.status = status;
+    this.listeners.forEach((listener) => listener(status));
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+};
+
+// src/sync/sync-manager.ts
+var DEFAULT_RETRY_INTERVAL_MS = 3e4;
+var MAX_UPLOADS_PER_MINUTE = 3;
+var FORCED_RETRY_MIN_GAP_MS = 1e4;
+var FORBIDDEN_PAUSE_MS = MAX_RETRY_AFTER_MS;
+var DEFAULT_RATE_LIMIT_PAUSE_MS = 6e4;
+var SyncManager = class {
+  constructor(apiClient, queue, retryIntervalMs = DEFAULT_RETRY_INTERVAL_MS, logger, onDelivered) {
+    this.apiClient = apiClient;
+    this.queue = queue;
+    this.retryIntervalMs = retryIntervalMs;
+    this.logger = logger;
+    this.onDelivered = onDelivered;
+  }
+  apiClient;
+  queue;
+  retryIntervalMs;
+  logger;
+  onDelivered;
+  retryTimer = null;
+  lastSyncAt = null;
+  lastUploadResult = null;
+  uploadTimes = [];
+  pausedUntil = 0;
+  lastForcedRetryAt = 0;
+  /**
+   * Write-ahead: the event is durably queued *before* any network attempt is
+   * made, so an app kill mid-request can never lose it (spec: "true
+   * write-ahead event persistence" — a prior version of this method tried
+   * the network first and only queued on failure, which meant an event in
+   * flight when the process died was gone for good). `attemptDelivery` then
+   * runs the exact same success/failure bookkeeping a queued retry uses, so
+   * there is only one code path for "what happens when an upload settles."
+   */
+  async sendOrQueue(payload) {
+    await this.queue.enqueue(payload);
+    if (!this.canUploadNow()) {
+      this.logger?.log("Upload deferred (rate cap or server asked to wait)", { eventId: payload.id });
+      return;
+    }
+    await this.attemptDelivery(payload.id, payload);
+  }
+  canUploadNow() {
+    const now = Date.now();
+    if (now < this.pausedUntil) return false;
+    this.uploadTimes = this.uploadTimes.filter((at) => now - at < 6e4);
+    return this.uploadTimes.length < MAX_UPLOADS_PER_MINUTE;
+  }
+  /**
+   * Attempts queued events. By default only ones whose backoff window has
+   * elapsed (the timer-driven path, `startAutoRetry` — the whole point of
+   * backoff is to not hammer the backend on a fixed sweep). Pass
+   * `{ force: true }` to ignore that window and attempt every non-in-flight
+   * queued event regardless — connectivity just being confirmed restored
+   * (see `GeoPulseSdk.start`'s network-monitor subscription) is a stronger
+   * signal than "some fixed delay has passed," and a device that was
+   * offline for a while shouldn't have to wait out a stale backoff timer
+   * once it's actually back online.
+   */
+  async retryPending(options = {}) {
+    let force = options.force === true;
+    if (force) {
+      const now = Date.now();
+      if (now - this.lastForcedRetryAt < FORCED_RETRY_MIN_GAP_MS) force = false;
+      else this.lastForcedRetryAt = now;
+    }
+    const ready = force ? (await this.queue.listPending()).filter((event) => event.status !== "sending") : await this.queue.listReadyForRetry();
+    const result = { attempted: 0, delivered: 0, failed: 0 };
+    for (const event of ready) {
+      if (!this.canUploadNow()) break;
+      result.attempted++;
+      const attemptNumber = event.attempts + 1;
+      const delivered = await this.attemptDelivery(event.eventId, { ...event.payload, attempts: attemptNumber });
+      if (delivered) {
+        result.delivered++;
+      } else {
+        result.failed++;
+      }
+    }
+    return result;
+  }
+  /**
+   * The single place that actually talks to the backend: marks the queued
+   * record "sending" (so a concurrent retry pass skips it), attempts the
+   * upload, and resolves it to either removed-from-queue (success — a
+   * `deduplicated: true` response still counts, since it means the backend
+   * already has this event id, which is exactly the outcome a retry is
+   * supposed to produce) or a scheduled retry (failure). Returns whether it
+   * was delivered, purely so `retryPending` can tally its `SyncResult`.
+   */
+  async attemptDelivery(eventId, payload) {
+    this.uploadTimes.push(Date.now());
+    await this.queue.markSending(eventId);
+    this.logger?.log("Event upload started", { eventId, attempt: payload.attempts });
+    let result;
+    try {
+      result = await this.apiClient.ingestEvent(payload);
+      await this.queue.markSent(eventId);
+      this.lastSyncAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.lastUploadResult = "success";
+      this.logger?.log("Event upload succeeded", { eventId });
+    } catch (error) {
+      this.lastUploadResult = "failure";
+      if (error instanceof ApiError && error.status === 429) {
+        const waitMs = error.retryAfterMs ?? DEFAULT_RATE_LIMIT_PAUSE_MS;
+        this.pausedUntil = Date.now() + waitMs;
+        await this.queue.markAttemptFailed(eventId, waitMs);
+        this.logger?.warn("Server rate limit \u2014 pausing uploads", { eventId, waitMs });
+      } else if (error instanceof ApiError && isPermanentRejection(error.status)) {
+        await this.queue.markSent(eventId);
+        if (error.status === 403) this.pausedUntil = Date.now() + FORBIDDEN_PAUSE_MS;
+        this.logger?.warn("Event rejected permanently \u2014 dropped", { eventId, status: error.status });
+      } else {
+        await this.queue.markAttemptFailed(eventId);
+        this.logger?.warn("Event upload failed \u2014 retry scheduled", { eventId, error: String(error) });
+      }
+      return false;
+    }
+    try {
+      this.onDelivered?.(result);
+    } catch (error) {
+      this.logger?.warn("onDelivered handler threw", { eventId, error: String(error) });
+    }
+    return true;
+  }
+  startAutoRetry() {
+    if (this.retryTimer) return;
+    this.retryTimer = setInterval(() => {
+      void this.retryPending();
+    }, this.retryIntervalMs);
+  }
+  stopAutoRetry() {
+    if (this.retryTimer) {
+      clearInterval(this.retryTimer);
+      this.retryTimer = null;
+    }
+  }
+  getLastSyncAt() {
+    return this.lastSyncAt;
+  }
+  getLastUploadResult() {
+    return this.lastUploadResult;
+  }
+};
+function isPermanentRejection(status) {
+  return status >= 400 && status < 500 && status !== 408 && status !== 429;
+}
+
+// src/core/logger.ts
+var Logger = class {
+  constructor(enabled) {
+    this.enabled = enabled;
+  }
+  enabled;
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  log(message, details) {
+    if (!this.enabled) return;
+    if (details) {
+      console.log(`[GeoPulse] ${message}`, details);
+    } else {
+      console.log(`[GeoPulse] ${message}`);
+    }
+  }
+  warn(message, details) {
+    if (!this.enabled) return;
+    if (details) {
+      console.warn(`[GeoPulse] ${message}`, details);
+    } else {
+      console.warn(`[GeoPulse] ${message}`);
+    }
+  }
+};
+
+// src/core/geo-pulse-sdk.ts
+var ApplicationMismatchError = class extends Error {
+  constructor() {
+    super("GeoPulse: the SDK key belongs to a different application than config.applicationId \u2014 check both values");
+    this.name = "ApplicationMismatchError";
+  }
+};
+var DEFAULT_EXPERIENCE_POLL_INTERVAL_MS = 15 * 6e4;
+var CONFIG_REFRESH_INTERVAL_MS = 60 * 6e4;
+var MIN_TIMER_INTERVAL_MS = 1e3;
+function clampIntervalMs(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Number.isFinite(value) || value < MIN_TIMER_INTERVAL_MS) {
+    return MIN_TIMER_INTERVAL_MS;
+  }
+  return value;
+}
+var GeoPulseSdk = class {
+  status = "idle";
+  config = null;
+  apiClient = null;
+  syncManager = null;
+  resolvedProjectId = null;
+  resolvedApplicationId = null;
+  applicationEnabled = true;
+  configVersion = null;
+  configurationStatus = "unsynced";
+  geofences = [];
+  lastKnownLocation = null;
+  lastEvent = null;
+  deviceId = null;
+  locationError = null;
+  unsubscribeNetwork = null;
+  stateMachine;
+  geofenceStateStore;
+  geofenceStateRestored = false;
+  realtime = null;
+  createRealtime;
+  lastConfigFetchAt = 0;
+  configRefreshInFlight = false;
+  listeners = /* @__PURE__ */ new Map();
+  experienceListeners = /* @__PURE__ */ new Set();
+  /** Client-side duplicate protection (spec section 14) — belt-and-suspenders alongside the server-side ack; a delivery already acked but re-observed before the ack lands must not fire `experience.received` twice. */
+  seenExperienceRevisions = /* @__PURE__ */ new Map();
+  experienceRemovedListeners = /* @__PURE__ */ new Set();
+  removedDeliveryIds = /* @__PURE__ */ new Set();
+  experiencePollTimer = null;
+  experiencePollInFlight = false;
+  /** Set while a poll that was refused with "too many requests" waits to be tried again. */
+  pollRetryTimer = null;
+  /** Set when a poll was asked for while one was already running; that one may have queried before the new delivery existed. */
+  experiencePollRequested = false;
+  experiencesReceivedCount = 0;
+  logger;
+  locationProvider;
+  permissionProvider;
+  queue;
+  buildApiClient;
+  deviceIdStore;
+  configCache;
+  networkMonitor;
+  getPlatform;
+  experiencePollIntervalMs = DEFAULT_EXPERIENCE_POLL_INTERVAL_MS;
+  constructor(dependencies = {}) {
+    this.locationProvider = dependencies.locationProvider ?? new SimulatedLocationProvider();
+    this.permissionProvider = dependencies.permissionProvider ?? new SimulatedPermissionProvider();
+    this.queue = dependencies.queue ?? new PendingEventQueue();
+    this.buildApiClient = dependencies.createApiClient ?? ((config) => new ApiClient(config.functionsBaseUrl || DEFAULT_BACKEND_URL, config.apiKey, config.applicationId));
+    this.deviceIdStore = dependencies.deviceIdStore ?? new InMemoryKeyValueStore();
+    this.configCache = new ConfigCache(dependencies.configCacheStore ?? new InMemoryKeyValueStore());
+    this.networkMonitor = dependencies.networkMonitor ?? new ManualNetworkMonitor();
+    this.getPlatform = dependencies.getPlatform ?? (() => "unknown");
+    this.logger = new Logger(dependencies.debug ?? false);
+    this.stateMachine = new GeofenceStateMachine(dependencies.stateMachineOptions);
+    this.geofenceStateStore = new GeofenceStateStore(dependencies.stateStore ?? new InMemoryKeyValueStore());
+    this.createRealtime = dependencies.createRealtimeClient;
+  }
+  /**
+   * Resolves this device's persistent id, then fetches (or falls back to
+   * cached) project configuration. Must succeed — fresh or cached — before
+   * `start()`; if neither is available (first-ever run with no network),
+   * this rethrows and `getStatus()` reports "error".
+   */
+  async initialize(config) {
+    if (this.status === "running") {
+      throw new Error("GeoPulse.initialize() cannot be called while already running \u2014 call GeoPulse.stop() first");
+    }
+    if (this.status === "initializing") {
+      throw new Error("GeoPulse.initialize() is already in progress \u2014 wait for the first call to resolve");
+    }
+    if (!config.apiKey || !config.applicationId) {
+      throw new Error("GeoPulse.initialize requires both apiKey and applicationId");
+    }
+    if (config.debug !== void 0) {
+      this.logger.setEnabled(config.debug);
+    }
+    this.logger.log("GeoPulse.initialize()", { applicationId: config.applicationId });
+    this.status = "initializing";
+    this.config = config;
+    this.experiencePollIntervalMs = clampIntervalMs(config.experiencePollIntervalMs) ?? DEFAULT_EXPERIENCE_POLL_INTERVAL_MS;
+    this.apiClient = this.buildApiClient(config);
+    this.syncManager = new SyncManager(
+      this.apiClient,
+      this.queue,
+      clampIntervalMs(config.retryIntervalMs),
+      this.logger,
+      (result) => this.handleEventDelivered(result)
+    );
+    this.deviceId = await getOrCreateDeviceId(this.deviceIdStore);
+    this.realtime?.disconnect();
+    this.realtime = this.createRealtime ? this.createRealtime({
+      baseUrl: config.functionsBaseUrl || DEFAULT_BACKEND_URL,
+      sdkKey: config.apiKey,
+      applicationId: config.applicationId,
+      deviceId: this.deviceId,
+      onChanged: () => void this.pollForExperiences(),
+      // Whatever changed while the socket was down is picked up now.
+      onConnected: () => void this.pollForExperiences(),
+      logger: this.logger
+    }) : null;
+    try {
+      const projectConfig = await this.apiClient.getProjectConfig({
+        deviceId: this.deviceId,
+        platform: this.getPlatform(),
+        sdkVersion: SDK_VERSION
+      });
+      if (projectConfig.applicationId !== config.applicationId) {
+        throw new ApplicationMismatchError();
+      }
+      this.applyProjectConfig(projectConfig);
+      this.configurationStatus = "synced";
+      this.lastConfigFetchAt = Date.now();
+      await this.configCache.save(projectConfig);
+      this.status = "initialized";
+      this.logger.log("Configuration synced", { geofenceCount: projectConfig.geofences.length, configVersion: projectConfig.configVersion });
+    } catch (error) {
+      if (error instanceof ApplicationMismatchError) {
+        this.configurationStatus = "unavailable";
+        this.status = "error";
+        throw error;
+      }
+      const cached = await this.configCache.load();
+      if (cached && cached.config.applicationId === config.applicationId) {
+        this.applyProjectConfig(cached.config);
+        this.configurationStatus = "cached";
+        this.status = "initialized";
+        this.logger.warn("getProjectConfig failed \u2014 using cached configuration", { fetchedAt: cached.fetchedAt });
+        return;
+      }
+      this.configurationStatus = "unavailable";
+      this.status = "error";
+      throw error;
+    }
+  }
+  async start() {
+    if (this.status === "running") {
+      throw new Error("GeoPulse.start() called while already running \u2014 call GeoPulse.stop() first if you want to restart");
+    }
+    if (this.status !== "initialized" && this.status !== "stopped") {
+      throw new Error("GeoPulse.start called before GeoPulse.initialize succeeded");
+    }
+    if (!this.applicationEnabled) {
+      this.status = "error";
+      throw new Error("This application has been disabled in the GeoPulse admin portal");
+    }
+    const permission = await this.permissionProvider.request();
+    if (permission !== "granted") {
+      this.status = "error";
+      throw new Error(`Location permission not granted (status: ${permission})`);
+    }
+    if (!this.geofenceStateRestored) {
+      this.geofenceStateRestored = true;
+      const saved = await this.geofenceStateStore.load();
+      if (saved) this.stateMachine.restoreState(saved);
+    }
+    this.locationError = null;
+    await this.locationProvider.start(
+      (location) => {
+        void this.handleLocationUpdate(location);
+      },
+      (error) => {
+        this.locationError = error.message;
+        this.logger.warn("Location provider failed to start", { error: error.message });
+      }
+    );
+    if (this.locationError) {
+      this.status = "error";
+      throw new Error(`GeoPulse failed to start location tracking: ${this.locationError}`);
+    }
+    this.unsubscribeNetwork = this.networkMonitor.subscribe((networkStatus) => {
+      if (networkStatus === "online") {
+        this.logger.log("Network available \u2014 retrying queued events");
+        void this.syncManager?.retryPending({ force: true });
+      }
+    });
+    this.syncManager?.startAutoRetry();
+    this.startExperiencePolling();
+    this.status = "running";
+    this.syncRealtime();
+    this.logger.log("GeoPulse.start()");
+  }
+  stop() {
+    this.locationProvider.stop();
+    this.syncManager?.stopAutoRetry();
+    this.stopExperiencePolling();
+    this.realtime?.disconnect();
+    this.unsubscribeNetwork?.();
+    this.unsubscribeNetwork = null;
+    this.status = "stopped";
+    this.logger.log("GeoPulse.stop()");
+  }
+  getStatus() {
+    return this.status;
+  }
+  async getPermissionStatus() {
+    return this.permissionProvider.getStatus();
+  }
+  on(eventName, callback) {
+    if (eventName === "experience.received") {
+      this.experienceListeners.add(callback);
+      return;
+    }
+    if (eventName === "experience.removed") {
+      this.experienceRemovedListeners.add(callback);
+      return;
+    }
+    if (!this.listeners.has(eventName)) {
+      this.listeners.set(eventName, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(eventName)?.add(callback);
+  }
+  off(eventName, callback) {
+    if (eventName === "experience.received") {
+      this.experienceListeners.delete(callback);
+      return;
+    }
+    if (eventName === "experience.removed") {
+      this.experienceRemovedListeners.delete(callback);
+      return;
+    }
+    this.listeners.get(eventName)?.delete(callback);
+  }
+  // --- Small read-only accessors beyond the core 7-method API, so a host
+  // app (see apps/playground) can build a status UI around the SDK without
+  // it needing to duplicate state the SDK already tracks internally. ---
+  getConfiguredGeofences() {
+    return this.geofences;
+  }
+  /** The server-resolved application id (from `getProjectConfig`), or null before `initialize()` completes. */
+  getApplicationId() {
+    return this.resolvedApplicationId;
+  }
+  getLastKnownLocation() {
+    return this.lastKnownLocation;
+  }
+  async getPendingEventCount() {
+    return (await this.queue.listPending()).length;
+  }
+  /** Null until `initialize()` resolves it — persisted across app restarts (see config/device-id.ts). */
+  getDeviceId() {
+    return this.deviceId;
+  }
+  /**
+   * The rich developer-diagnostics snapshot (spec section 10/11) — a
+   * superset of `getStatus()`, not a replacement for it (see core/types.ts's
+   * `DiagnosticsSnapshot` doc for why these are two separate methods).
+   */
+  async getDiagnostics() {
+    const pending = await this.queue.listPending();
+    const permissionStatus = this.status === "idle" || this.status === "initializing" ? "unknown" : await this.permissionProvider.getStatus();
+    return {
+      initialized: this.status !== "idle" && this.status !== "initializing",
+      running: this.status === "running",
+      locationAvailable: this.lastKnownLocation !== null,
+      permissionStatus,
+      networkStatus: this.networkMonitor.getStatus(),
+      configurationStatus: this.configurationStatus,
+      configVersion: this.configVersion,
+      pendingEvents: pending.length,
+      totalRetryAttempts: pending.reduce((sum, event) => sum + event.attempts, 0),
+      locationError: this.locationError,
+      lastEventAt: this.lastEvent?.timestamp ?? null,
+      lastEventType: this.lastEvent?.type ?? null,
+      lastSyncAt: this.syncManager?.getLastSyncAt() ?? null,
+      lastUploadResult: this.syncManager?.getLastUploadResult() ?? null,
+      deviceId: this.deviceId,
+      sdkVersion: SDK_VERSION,
+      experiencesReceivedCount: this.experiencesReceivedCount
+    };
+  }
+  /**
+   * Only functional when the SDK is running the simulated location
+   * provider (the default outside of production builds — see
+   * src/index.ts) and gated by `__DEV__` so it's inert in a production
+   * bundle even if a caller somehow held a reference to it.
+   */
+  simulateLocation(coords) {
+    const isDev2 = typeof __DEV__ === "undefined" ? true : __DEV__;
+    if (!isDev2) {
+      console.warn("GeoPulse.simulator is unavailable in production builds.");
+      return;
+    }
+    if (!(this.locationProvider instanceof SimulatedLocationProvider)) {
+      console.warn(
+        "GeoPulse.simulator.setLocation has no effect: the SDK is not running the simulated location provider."
+      );
+      return;
+    }
+    this.locationProvider.setLocation(coords);
+  }
+  /**
+   * The Phase 5B delivery mechanism: poll immediately on `start()` (so a
+   * demo doesn't wait a full interval for the first check), then on a
+   * timer. A poll failure (network blip, backend down) is logged and
+   * swallowed — it must never crash the SDK or the host app (spec section
+   * 13), and the next tick tries again on its own.
+   */
+  startExperiencePolling() {
+    void this.pollForExperiences();
+    this.experiencePollTimer = setInterval(() => {
+      void this.pollForExperiences();
+      void this.refreshConfigIfStale();
+    }, this.experiencePollIntervalMs);
+  }
+  stopExperiencePolling() {
+    if (this.pollRetryTimer) {
+      clearTimeout(this.pollRetryTimer);
+      this.pollRetryTimer = null;
+    }
+    if (this.experiencePollTimer) {
+      clearInterval(this.experiencePollTimer);
+      this.experiencePollTimer = null;
+    }
+  }
+  /**
+   * The backend says in its ingest response whether the event created an experience for this
+   * device. Poll right away if so (or if it doesn't say — an older backend), skip if it says
+   * there is nothing. Does nothing unless polling is active, so a stopped SDK never polls.
+   */
+  handleEventDelivered(result) {
+    if (this.experiencePollTimer === null || result?.experiencesPending === false) {
+      return;
+    }
+    void this.pollForExperiences();
+  }
+  /** One poll at a time: a second request while one is running makes it run once more afterwards, rather than overlapping. */
+  async pollForExperiences() {
+    if (this.experiencePollInFlight) {
+      this.experiencePollRequested = true;
+      return;
+    }
+    this.experiencePollInFlight = true;
+    try {
+      do {
+        this.experiencePollRequested = false;
+        await this.pollForExperiencesOnce();
+      } while (this.experiencePollRequested);
+    } finally {
+      this.experiencePollInFlight = false;
+    }
+  }
+  async pollForExperiencesOnce() {
+    if (!this.apiClient || !this.deviceId) {
+      return;
+    }
+    try {
+      const { experiences, revoked } = await this.apiClient.getPendingExperiences(this.deviceId);
+      for (const experience of experiences) {
+        const revision = experience.revision ?? 0;
+        const seenRevision = this.seenExperienceRevisions.get(experience.deliveryId);
+        if (seenRevision === revision) {
+          continue;
+        }
+        const isUpdate = seenRevision !== void 0;
+        this.seenExperienceRevisions.set(experience.deliveryId, revision);
+        this.removedDeliveryIds.delete(experience.deliveryId);
+        this.experiencesReceivedCount += 1;
+        this.logger.log("Experience received", { deliveryId: experience.deliveryId, campaignId: experience.campaignId, isUpdate });
+        this.experienceListeners.forEach((listener) => listener({ ...experience, isUpdate }));
+        await this.apiClient.acknowledgeExperienceDelivery(experience.deliveryId).catch((error) => {
+          this.logger.warn("Failed to acknowledge experience delivery", {
+            deliveryId: experience.deliveryId,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        });
+      }
+      for (const removed of revoked) {
+        if (!this.removedDeliveryIds.has(removed.deliveryId)) {
+          this.removedDeliveryIds.add(removed.deliveryId);
+          this.seenExperienceRevisions.delete(removed.deliveryId);
+          this.logger.log("Experience removed", { deliveryId: removed.deliveryId, campaignId: removed.campaignId });
+          this.experienceRemovedListeners.forEach((listener) => listener(removed));
+        }
+        await this.apiClient.acknowledgeExperienceDelivery(removed.deliveryId).catch((error) => {
+          this.logger.warn("Failed to acknowledge experience removal", {
+            deliveryId: removed.deliveryId,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        });
+      }
+    } catch (error) {
+      this.logger.warn("Polling for experiences failed", { error: error instanceof Error ? error.message : String(error) });
+      if (error instanceof ApiError && error.status === 429) {
+        this.schedulePollRetry(error.retryAfterMs ?? 3e4);
+      }
+    }
+  }
+  schedulePollRetry(waitMs) {
+    if (this.pollRetryTimer !== null || this.experiencePollTimer === null) {
+      return;
+    }
+    this.pollRetryTimer = setTimeout(() => {
+      this.pollRetryTimer = null;
+      void this.pollForExperiences();
+    }, waitMs + Math.random() * 5e3);
+  }
+  /**
+   * Re-reads the geofence list when it is an hour old, so a geofence an admin added, moved, resized or removed reaches a phone
+   * that keeps the app open (otherwise only a restart picks it up). Runs from the poll timer, so it costs no timer of its own.
+   * A failure keeps the list we have. A disabled application stops the SDK.
+   */
+  async refreshConfigIfStale() {
+    if (!this.apiClient || !this.deviceId || !this.config || this.configRefreshInFlight) {
+      return;
+    }
+    if (Date.now() - this.lastConfigFetchAt < CONFIG_REFRESH_INTERVAL_MS) {
+      return;
+    }
+    this.configRefreshInFlight = true;
+    try {
+      const projectConfig = await this.apiClient.getProjectConfig({ deviceId: this.deviceId, platform: this.getPlatform(), sdkVersion: SDK_VERSION });
+      if (projectConfig.applicationId !== this.config.applicationId) {
+        return;
+      }
+      this.lastConfigFetchAt = Date.now();
+      this.applyProjectConfig(projectConfig);
+      this.configurationStatus = "synced";
+      await this.configCache.save(projectConfig);
+      this.logger.log("Configuration refreshed", { geofenceCount: projectConfig.geofences.length, configVersion: projectConfig.configVersion });
+      if (!projectConfig.applicationEnabled) {
+        this.logger.warn("Application disabled \u2014 stopping");
+        this.stop();
+        this.status = "error";
+      }
+    } catch (error) {
+      this.logger.warn("Configuration refresh failed \u2014 keeping the current geofences", { error: error instanceof Error ? error.message : String(error) });
+    } finally {
+      this.configRefreshInFlight = false;
+    }
+  }
+  /** Keeps the push connection open exactly while the user is inside a geofence. */
+  syncRealtime() {
+    if (!this.realtime || this.status === "stopped") {
+      return;
+    }
+    if (this.stateMachine.isInsideAny()) {
+      this.realtime.connect();
+    } else {
+      this.realtime.disconnect();
+    }
+  }
+  async persistGeofenceState() {
+    await this.geofenceStateStore.save(this.stateMachine.exportState());
+  }
+  applyProjectConfig(projectConfig) {
+    this.resolvedProjectId = projectConfig.projectId;
+    this.resolvedApplicationId = projectConfig.applicationId;
+    this.applicationEnabled = projectConfig.applicationEnabled;
+    this.configVersion = projectConfig.configVersion;
+    this.geofences = projectConfig.geofences;
+  }
+  async handleLocationUpdate(location) {
+    this.lastKnownLocation = location;
+    if (!this.resolvedProjectId || !this.resolvedApplicationId || !this.syncManager || !this.deviceId) {
+      return;
+    }
+    const transitions = this.stateMachine.evaluate(location, this.geofences);
+    if (transitions.length > 0) {
+      void this.persistGeofenceState();
+    }
+    this.syncRealtime();
+    for (const transition of transitions) {
+      this.logger.log("Geofence state changed", { geofenceId: transition.geofence.id, type: transition.type });
+      const event = createEventPayload({
+        type: transition.type,
+        projectId: this.resolvedProjectId,
+        applicationId: this.resolvedApplicationId,
+        geofence: transition.geofence,
+        location,
+        deviceId: this.deviceId
+      });
+      this.lastEvent = event;
+      this.logger.log("Event generated", { eventId: event.id, type: event.type });
+      this.listeners.get(transition.type)?.forEach((listener) => listener(event));
+      await this.syncManager.sendOrQueue(event);
+    }
+  }
+};
+
+// src/location/device-location-provider.ts
+var Location = __toESM(require("expo-location"));
+var DeviceLocationProvider = class {
+  subscription = null;
+  /**
+   * `watchPositionAsync` rejects if location services are off at the OS
+   * level (distinct from the app's own permission grant, which is checked
+   * before this ever runs) — caught here and reported via `onError` instead
+   * of left to reject this method's own promise, so a caller that doesn't
+   * wrap `GeoPulse.start()` in a try/catch still can't end up with an
+   * unhandled rejection from deep inside a native module.
+   */
+  async start(onUpdate, onError) {
+    try {
+      this.subscription = await Location.watchPositionAsync(
+        { accuracy: Location.Accuracy.Balanced, timeInterval: 5e3, distanceInterval: 10 },
+        (position) => {
+          onUpdate({
+            latitude: position.coords.latitude,
+            longitude: position.coords.longitude,
+            timestamp: new Date(position.timestamp).toISOString(),
+            ...typeof position.coords.accuracy === "number" ? { accuracy: position.coords.accuracy } : {}
+          });
+        }
+      );
+    } catch (error) {
+      onError?.(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  stop() {
+    this.subscription?.remove();
+    this.subscription = null;
+  }
+};
+
+// src/permissions/expo-permission-provider.ts
+var Location2 = __toESM(require("expo-location"));
+function mapExpoStatus(status) {
+  switch (status) {
+    case Location2.PermissionStatus.GRANTED:
+      return "granted";
+    case Location2.PermissionStatus.DENIED:
+      return "denied";
+    default:
+      return "undetermined";
+  }
+}
+var ExpoPermissionProvider = class {
+  async getStatus() {
+    const { status } = await Location2.getForegroundPermissionsAsync();
+    return mapExpoStatus(status);
+  }
+  async request() {
+    const { status } = await Location2.requestForegroundPermissionsAsync();
+    return mapExpoStatus(status);
+  }
+};
+
+// src/storage/async-storage-store.ts
+var import_async_storage2 = __toESM(require("@react-native-async-storage/async-storage"));
+var STORAGE_KEY2 = "@geopulse/pending-events";
+var AsyncStorageEventQueueStore = class {
+  async getAll() {
+    const raw = await import_async_storage2.default.getItem(STORAGE_KEY2);
+    if (!raw) return [];
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return [];
+    }
+  }
+  async save(event) {
+    const all = await this.getAll();
+    const next = [...all.filter((existing) => existing.eventId !== event.eventId), event];
+    await import_async_storage2.default.setItem(STORAGE_KEY2, JSON.stringify(next));
+  }
+  async remove(eventId) {
+    const all = await this.getAll();
+    await import_async_storage2.default.setItem(STORAGE_KEY2, JSON.stringify(all.filter((existing) => existing.eventId !== eventId)));
+  }
+};
+
+// src/realtime/realtime-client.ts
+var RECONNECT_BASE_MS = 5e3;
+var RECONNECT_MAX_MS = 5 * 6e4;
+var NO_RETRY_CODES = /* @__PURE__ */ new Set([4400, 4401, 4403]);
+function toRealtimeUrl(baseUrl) {
+  return `${baseUrl.replace(/\/+$/, "").replace(/^http/, "ws")}/realtime`;
+}
+var RealtimeClient = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  socket = null;
+  connected = false;
+  wanted = false;
+  failures = 0;
+  reconnectTimer = null;
+  isConnected() {
+    return this.connected;
+  }
+  connect() {
+    this.wanted = true;
+    if (this.socket || this.reconnectTimer) return;
+    this.open();
+  }
+  disconnect() {
+    this.wanted = false;
+    this.failures = 0;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    const socket = this.socket;
+    this.socket = null;
+    this.connected = false;
+    if (socket) {
+      socket.onclose = null;
+      socket.onmessage = null;
+      socket.onerror = null;
+      try {
+        socket.close(1e3, "done");
+      } catch {
+      }
+    }
+  }
+  open() {
+    const create = this.options.createSocket ?? defaultCreateSocket;
+    let socket;
+    try {
+      socket = create(toRealtimeUrl(this.options.baseUrl));
+    } catch (error) {
+      this.options.logger?.warn("Realtime unavailable", { error: String(error) });
+      return;
+    }
+    if (!socket) return;
+    this.socket = socket;
+    socket.onopen = () => {
+      socket.send(JSON.stringify({ type: "hello", sdkKey: this.options.sdkKey, applicationId: this.options.applicationId, deviceId: this.options.deviceId }));
+    };
+    socket.onmessage = (event) => {
+      let message = null;
+      try {
+        message = JSON.parse(String(event.data));
+      } catch {
+        return;
+      }
+      if (message?.type === "ready") {
+        this.connected = true;
+        this.failures = 0;
+        this.options.onConnected();
+      } else if (message?.type === "changed") {
+        this.options.onChanged();
+      }
+    };
+    socket.onerror = () => {
+    };
+    socket.onclose = (event) => {
+      this.socket = null;
+      this.connected = false;
+      if (!this.wanted) return;
+      if (NO_RETRY_CODES.has(event.code)) {
+        this.options.logger?.warn("Realtime rejected by the server; not retrying", { code: event.code });
+        return;
+      }
+      this.failures += 1;
+      const delay = Math.min(RECONNECT_BASE_MS * 2 ** (this.failures - 1), RECONNECT_MAX_MS);
+      this.reconnectTimer = setTimeout(() => {
+        this.reconnectTimer = null;
+        if (this.wanted) this.open();
+      }, Math.round(delay * (0.8 + Math.random() * 0.4)));
+    };
+  }
+};
+function defaultCreateSocket(url) {
+  const Ctor = globalThis.WebSocket;
+  return Ctor ? new Ctor(url) : null;
+}
+
+// src/sync/netinfo-network-monitor.ts
+var import_netinfo = __toESM(require("@react-native-community/netinfo"));
+function toStatus(isConnected) {
+  if (isConnected === null) return "unknown";
+  return isConnected ? "online" : "offline";
+}
+var NetInfoNetworkMonitor = class {
+  status = "unknown";
+  constructor() {
+    import_netinfo.default.fetch().then((state) => {
+      this.status = toStatus(state.isConnected);
+    });
+  }
+  getStatus() {
+    return this.status;
+  }
+  subscribe(listener) {
+    return import_netinfo.default.addEventListener((state) => {
+      this.status = toStatus(state.isConnected);
+      listener(this.status);
+    });
+  }
+};
+
+// src/rendering/experience-components.tsx
+var import_react = __toESM(require("react"));
+var import_react_native = require("react-native");
+function isSafeExternalUrl(url) {
+  return typeof url === "string" && /^https?:\/\/[^\s]+$/i.test(url);
+}
+function openUrl(url) {
+  if (!isSafeExternalUrl(url)) return;
+  import_react_native.Linking.openURL(url).catch(() => {
+  });
+}
+function ExperienceButton({ style, ctaLabel, ctaUrl }) {
+  if (!style.button.visible || !ctaLabel || !ctaUrl) return null;
+  const { position } = style.button;
+  return /* @__PURE__ */ import_react.default.createElement(
+    import_react_native.TouchableOpacity,
+    {
+      onPress: () => openUrl(ctaUrl),
+      style: {
+        position: "absolute",
+        top: position.top ?? void 0,
+        bottom: position.bottom ?? void 0,
+        left: position.left ?? void 0,
+        right: position.right ?? void 0,
+        backgroundColor: style.button.backgroundColor,
+        borderRadius: style.button.borderRadius,
+        paddingVertical: 10,
+        paddingHorizontal: 16
+      }
+    },
+    /* @__PURE__ */ import_react.default.createElement(import_react_native.Text, { style: { color: style.button.textColor, fontWeight: "600" } }, ctaLabel)
+  );
+}
+function ExperienceContainer({ content, style, children }) {
+  const containerStyle = {
+    backgroundColor: style.container.backgroundColor,
+    borderColor: style.container.borderColor ?? void 0,
+    borderWidth: style.container.borderWidth,
+    borderRadius: style.container.borderRadius,
+    padding: style.container.padding,
+    overflow: "hidden",
+    width: style.container.width === "fill" ? "100%" : style.container.width,
+    // "auto" means no explicit height at all — RN sizes a View to its content by default, so
+    // omitting the property (rather than passing "auto", which RN's height type doesn't accept)
+    // is what actually produces that behavior.
+    // The button is absolutely positioned, so it takes no layout space — without a floor, an
+    // "auto" container shrinks to title+body and the button overlaps them. 160 matches the
+    // admin-web preview (experience-preview.tsx) so the device renders what the portal shows.
+    ...style.container.height === "auto" ? { minHeight: 160 } : { height: style.container.height }
+  };
+  const backgroundImage = isSafeExternalUrl(style.container.backgroundImageUrl) ? /* @__PURE__ */ import_react.default.createElement(
+    import_react_native.Image,
+    {
+      source: { uri: style.container.backgroundImageUrl },
+      resizeMode: style.container.backgroundImageFit,
+      style: { position: "absolute", top: 0, left: 0, right: 0, bottom: 0 }
+    }
+  ) : null;
+  if (content.cardNavigationUrl) {
+    const cardNavigationUrl = content.cardNavigationUrl;
+    return /* @__PURE__ */ import_react.default.createElement(import_react_native.TouchableOpacity, { testID: "experience-container", onPress: () => openUrl(cardNavigationUrl), style: containerStyle }, backgroundImage, children);
+  }
+  return /* @__PURE__ */ import_react.default.createElement(import_react_native.View, { testID: "experience-container", style: containerStyle }, backgroundImage, children);
+}
+function ExperienceText({ visible, text, color, fontSize, fontWeight }) {
+  if (!visible) return null;
+  return /* @__PURE__ */ import_react.default.createElement(import_react_native.Text, { style: { color, fontSize, fontWeight } }, text);
+}
+function CardExperience({ content }) {
+  const style = resolveExperienceStyle("card", content.style);
+  return /* @__PURE__ */ import_react.default.createElement(ExperienceContainer, { content, style }, /* @__PURE__ */ import_react.default.createElement(ExperienceText, { visible: style.title.visible, text: content.title, color: style.title.color, fontSize: style.title.fontSize, fontWeight: style.title.fontWeight }), /* @__PURE__ */ import_react.default.createElement(ExperienceText, { visible: style.body.visible, text: content.body, color: style.body.color, fontSize: style.body.fontSize, fontWeight: style.body.fontWeight }), /* @__PURE__ */ import_react.default.createElement(ExperienceButton, { style, ctaLabel: content.ctaLabel, ctaUrl: content.ctaUrl }));
+}
+function BannerExperience({ content }) {
+  const style = resolveExperienceStyle("banner", content.style);
+  return /* @__PURE__ */ import_react.default.createElement(ExperienceContainer, { content, style }, /* @__PURE__ */ import_react.default.createElement(ExperienceText, { visible: style.title.visible, text: content.title, color: style.title.color, fontSize: style.title.fontSize, fontWeight: style.title.fontWeight }), /* @__PURE__ */ import_react.default.createElement(ExperienceText, { visible: style.body.visible, text: content.body, color: style.body.color, fontSize: style.body.fontSize, fontWeight: style.body.fontWeight }), /* @__PURE__ */ import_react.default.createElement(ExperienceButton, { style, ctaLabel: content.ctaLabel, ctaUrl: content.ctaUrl }));
+}
+function AlertExperience({ content }) {
+  const style = resolveExperienceStyle("alert", content.style);
+  return /* @__PURE__ */ import_react.default.createElement(ExperienceContainer, { content, style }, /* @__PURE__ */ import_react.default.createElement(ExperienceText, { visible: style.title.visible, text: content.title, color: style.title.color, fontSize: style.title.fontSize, fontWeight: style.title.fontWeight }), /* @__PURE__ */ import_react.default.createElement(ExperienceText, { visible: style.body.visible, text: content.body, color: style.body.color, fontSize: style.body.fontSize, fontWeight: style.body.fontWeight }), /* @__PURE__ */ import_react.default.createElement(ExperienceButton, { style, ctaLabel: content.ctaLabel, ctaUrl: content.ctaUrl }));
+}
+function isAlertExperience(payload) {
+  return payload.experience.type === "alert";
+}
+function MessageExperience({ content }) {
+  const style = resolveExperienceStyle("message", content.style);
+  return /* @__PURE__ */ import_react.default.createElement(ExperienceContainer, { content, style }, /* @__PURE__ */ import_react.default.createElement(ExperienceText, { visible: style.title.visible, text: content.title, color: style.title.color, fontSize: style.title.fontSize, fontWeight: style.title.fontWeight }), /* @__PURE__ */ import_react.default.createElement(ExperienceText, { visible: style.body.visible, text: content.body, color: style.body.color, fontSize: style.body.fontSize, fontWeight: style.body.fontWeight }), /* @__PURE__ */ import_react.default.createElement(ExperienceButton, { style, ctaLabel: content.ctaLabel, ctaUrl: content.ctaUrl }));
+}
+function ExperienceView({ experience }) {
+  switch (experience.type) {
+    case "banner":
+      return /* @__PURE__ */ import_react.default.createElement(BannerExperience, { content: experience });
+    case "message":
+      return /* @__PURE__ */ import_react.default.createElement(MessageExperience, { content: experience });
+    case "alert":
+      return /* @__PURE__ */ import_react.default.createElement(AlertExperience, { content: experience });
+    case "card":
+    default:
+      return /* @__PURE__ */ import_react.default.createElement(CardExperience, { content: experience });
+  }
+}
+
+// src/index.ts
+var isDev = typeof __DEV__ === "undefined" ? true : __DEV__;
+var useRealLocationInDev = process.env.EXPO_PUBLIC_GEOPULSE_USE_REAL_LOCATION === "true";
+var useSimulatedProviders = isDev && !useRealLocationInDev;
+function getPlatform() {
+  switch (import_react_native2.Platform.OS) {
+    case "ios":
+    case "android":
+    case "web":
+      return import_react_native2.Platform.OS;
+    default:
+      return "unknown";
+  }
+}
+var persistentKeyValueStore = new AsyncStorageKeyValueStore();
+var sdk = new GeoPulseSdk({
+  locationProvider: useSimulatedProviders ? new SimulatedLocationProvider() : new DeviceLocationProvider(),
+  permissionProvider: useSimulatedProviders ? new SimulatedPermissionProvider() : new ExpoPermissionProvider(),
+  queue: new PendingEventQueue(new AsyncStorageEventQueueStore()),
+  deviceIdStore: persistentKeyValueStore,
+  configCacheStore: persistentKeyValueStore,
+  // The simulator is for trying things out: no 2-minute cooldown, and no saved "inside" state surviving a reload
+  // (otherwise "enter" would not fire again after Fast Refresh while the saved state says you are still inside).
+  stateStore: useSimulatedProviders ? void 0 : persistentKeyValueStore,
+  stateMachineOptions: useSimulatedProviders ? { cooldownMs: 0 } : void 0,
+  createRealtimeClient: (options) => new RealtimeClient(options),
+  networkMonitor: new NetInfoNetworkMonitor(),
+  getPlatform,
+  debug: isDev
+});
+var GeoPulse = {
+  initialize: (config) => sdk.initialize(config),
+  start: () => sdk.start(),
+  stop: () => sdk.stop(),
+  getStatus: () => sdk.getStatus(),
+  getPermissionStatus: () => sdk.getPermissionStatus(),
+  on: sdk.on.bind(sdk),
+  off: sdk.off.bind(sdk),
+  // Small additions beyond the core 7-method API, for building a status UI
+  // around the SDK (see apps/playground) — not part of the minimal public
+  // surface the spec calls out, but plain read-only accessors for state the
+  // SDK already tracks internally.
+  getConfiguredGeofences: () => sdk.getConfiguredGeofences(),
+  getApplicationId: () => sdk.getApplicationId(),
+  getLastKnownLocation: () => sdk.getLastKnownLocation(),
+  getPendingEventCount: () => sdk.getPendingEventCount(),
+  getDeviceId: () => sdk.getDeviceId(),
+  /** Rich developer-diagnostics snapshot — see core/types.ts's DiagnosticsSnapshot doc. */
+  getDiagnostics: () => sdk.getDiagnostics(),
+  /** Development-only. No-ops (with a console warning) in a production build — see GeoPulseSdk.simulateLocation. */
+  simulator: {
+    setLocation: (coords) => sdk.simulateLocation(coords)
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AlertExperience,
+  ApplicationMismatchError,
+  BannerExperience,
+  CardExperience,
+  DeviceLocationProvider,
+  ExperienceView,
+  ExpoPermissionProvider,
+  GeoPulse,
+  GeoPulseSdk,
+  ManualNetworkMonitor,
+  MessageExperience,
+  NetInfoNetworkMonitor,
+  SimulatedLocationProvider,
+  SimulatedPermissionProvider,
+  isAlertExperience
+});
+//# sourceMappingURL=index.js.map