@robinhealth/health-sdk 0.0.1

package/src/providers/healthkit.ts

@@ -0,0 +1,499 @@
+import Healthkit, {
+  type QuantityTypeIdentifier,
+  type CategoryTypeIdentifier,
+  type StatisticsOptions,
+  WorkoutActivityType as HKWorkoutActivityType,
+} from '@kingstinct/react-native-healthkit';
+import {
+  HealthDataType,
+  WorkoutActivityType,
+  PermissionStatus,
+  SleepStage,
+  type HealthProvider,
+  type HealthSample,
+  type HealthAggregate,
+  type Workout,
+  type SleepStageSample,
+  type SleepSession,
+} from '../types';
+import { getPermissionsRequested, setPermissionsRequested } from '../storage';
+
+type HKIdentifier = QuantityTypeIdentifier | CategoryTypeIdentifier;
+
+interface TypeMapping {
+  identifier: HKIdentifier;
+  unit: string;
+  isCategory?: boolean;
+}
+
+const TYPE_MAP: Partial<Record<HealthDataType, TypeMapping>> = {
+  [HealthDataType.Steps]: {
+    identifier: 'HKQuantityTypeIdentifierStepCount',
+    unit: 'count',
+  },
+  [HealthDataType.DistanceWalkingRunning]: {
+    identifier: 'HKQuantityTypeIdentifierDistanceWalkingRunning',
+    unit: 'm',
+  },
+  [HealthDataType.ActiveEnergyBurned]: {
+    identifier: 'HKQuantityTypeIdentifierActiveEnergyBurned',
+    unit: 'kcal',
+  },
+  [HealthDataType.FlightsClimbed]: {
+    identifier: 'HKQuantityTypeIdentifierFlightsClimbed',
+    unit: 'count',
+  },
+  [HealthDataType.HeartRate]: {
+    identifier: 'HKQuantityTypeIdentifierHeartRate',
+    unit: 'bpm',
+  },
+  [HealthDataType.RestingHeartRate]: {
+    identifier: 'HKQuantityTypeIdentifierRestingHeartRate',
+    unit: 'bpm',
+  },
+  [HealthDataType.BloodPressureSystolic]: {
+    identifier: 'HKQuantityTypeIdentifierBloodPressureSystolic',
+    unit: 'mmHg',
+  },
+  [HealthDataType.BloodPressureDiastolic]: {
+    identifier: 'HKQuantityTypeIdentifierBloodPressureDiastolic',
+    unit: 'mmHg',
+  },
+  [HealthDataType.BloodOxygen]: {
+    identifier: 'HKQuantityTypeIdentifierOxygenSaturation',
+    unit: '%',
+  },
+  [HealthDataType.RespiratoryRate]: {
+    identifier: 'HKQuantityTypeIdentifierRespiratoryRate',
+    unit: 'breaths/min',
+  },
+  [HealthDataType.SleepAnalysis]: {
+    identifier: 'HKCategoryTypeIdentifierSleepAnalysis',
+    unit: 'hr',
+    isCategory: true,
+  },
+  [HealthDataType.BodyFatPercentage]: {
+    identifier: 'HKQuantityTypeIdentifierBodyFatPercentage',
+    unit: '%',
+  },
+  [HealthDataType.BodyMassIndex]: {
+    identifier: 'HKQuantityTypeIdentifierBodyMassIndex',
+    unit: 'kg/m²',
+  },
+  [HealthDataType.BasalEnergyBurned]: {
+    identifier: 'HKQuantityTypeIdentifierBasalEnergyBurned',
+    unit: 'kcal',
+  },
+  [HealthDataType.Water]: {
+    identifier: 'HKQuantityTypeIdentifierDietaryWater',
+    unit: 'mL',
+  },
+};
+
+const WORKOUT_TYPE_MAP: Record<number, WorkoutActivityType> = {
+  [HKWorkoutActivityType.americanFootball]: WorkoutActivityType.americanFootball,
+  [HKWorkoutActivityType.archery]: WorkoutActivityType.archery,
+  [HKWorkoutActivityType.australianFootball]: WorkoutActivityType.australianFootball,
+  [HKWorkoutActivityType.badminton]: WorkoutActivityType.badminton,
+  [HKWorkoutActivityType.baseball]: WorkoutActivityType.baseball,
+  [HKWorkoutActivityType.basketball]: WorkoutActivityType.basketball,
+  [HKWorkoutActivityType.bowling]: WorkoutActivityType.bowling,
+  [HKWorkoutActivityType.boxing]: WorkoutActivityType.boxing,
+  [HKWorkoutActivityType.climbing]: WorkoutActivityType.climbing,
+  [HKWorkoutActivityType.cricket]: WorkoutActivityType.cricket,
+  [HKWorkoutActivityType.crossTraining]: WorkoutActivityType.crossTraining,
+  [HKWorkoutActivityType.curling]: WorkoutActivityType.curling,
+  [HKWorkoutActivityType.cycling]: WorkoutActivityType.cycling,
+  [HKWorkoutActivityType.dance]: WorkoutActivityType.dance,
+  [HKWorkoutActivityType.danceInspiredTraining]: WorkoutActivityType.danceInspiredTraining,
+  [HKWorkoutActivityType.elliptical]: WorkoutActivityType.elliptical,
+  [HKWorkoutActivityType.equestrianSports]: WorkoutActivityType.equestrianSports,
+  [HKWorkoutActivityType.fencing]: WorkoutActivityType.fencing,
+  [HKWorkoutActivityType.fishing]: WorkoutActivityType.fishing,
+  [HKWorkoutActivityType.functionalStrengthTraining]: WorkoutActivityType.functionalStrengthTraining,
+  [HKWorkoutActivityType.golf]: WorkoutActivityType.golf,
+  [HKWorkoutActivityType.gymnastics]: WorkoutActivityType.gymnastics,
+  [HKWorkoutActivityType.handball]: WorkoutActivityType.handball,
+  [HKWorkoutActivityType.hiking]: WorkoutActivityType.hiking,
+  [HKWorkoutActivityType.hockey]: WorkoutActivityType.hockey,
+  [HKWorkoutActivityType.hunting]: WorkoutActivityType.hunting,
+  [HKWorkoutActivityType.lacrosse]: WorkoutActivityType.lacrosse,
+  [HKWorkoutActivityType.martialArts]: WorkoutActivityType.martialArts,
+  [HKWorkoutActivityType.mindAndBody]: WorkoutActivityType.mindAndBody,
+  [HKWorkoutActivityType.mixedMetabolicCardioTraining]: WorkoutActivityType.mixedMetabolicCardioTraining,
+  [HKWorkoutActivityType.paddleSports]: WorkoutActivityType.paddleSports,
+  [HKWorkoutActivityType.play]: WorkoutActivityType.play,
+  [HKWorkoutActivityType.preparationAndRecovery]: WorkoutActivityType.preparationAndRecovery,
+  [HKWorkoutActivityType.racquetball]: WorkoutActivityType.racquetball,
+  [HKWorkoutActivityType.rowing]: WorkoutActivityType.rowing,
+  [HKWorkoutActivityType.rugby]: WorkoutActivityType.rugby,
+  [HKWorkoutActivityType.running]: WorkoutActivityType.running,
+  [HKWorkoutActivityType.sailing]: WorkoutActivityType.sailing,
+  [HKWorkoutActivityType.skatingSports]: WorkoutActivityType.skatingSports,
+  [HKWorkoutActivityType.snowSports]: WorkoutActivityType.snowSports,
+  [HKWorkoutActivityType.soccer]: WorkoutActivityType.soccer,
+  [HKWorkoutActivityType.softball]: WorkoutActivityType.softball,
+  [HKWorkoutActivityType.squash]: WorkoutActivityType.squash,
+  [HKWorkoutActivityType.stairClimbing]: WorkoutActivityType.stairClimbing,
+  [HKWorkoutActivityType.surfingSports]: WorkoutActivityType.surfingSports,
+  [HKWorkoutActivityType.swimming]: WorkoutActivityType.swimming,
+  [HKWorkoutActivityType.tableTennis]: WorkoutActivityType.tableTennis,
+  [HKWorkoutActivityType.tennis]: WorkoutActivityType.tennis,
+  [HKWorkoutActivityType.trackAndField]: WorkoutActivityType.trackAndField,
+  [HKWorkoutActivityType.traditionalStrengthTraining]: WorkoutActivityType.traditionalStrengthTraining,
+  [HKWorkoutActivityType.volleyball]: WorkoutActivityType.volleyball,
+  [HKWorkoutActivityType.walking]: WorkoutActivityType.walking,
+  [HKWorkoutActivityType.waterFitness]: WorkoutActivityType.waterFitness,
+  [HKWorkoutActivityType.waterPolo]: WorkoutActivityType.waterPolo,
+  [HKWorkoutActivityType.waterSports]: WorkoutActivityType.waterSports,
+  [HKWorkoutActivityType.wrestling]: WorkoutActivityType.wrestling,
+  [HKWorkoutActivityType.yoga]: WorkoutActivityType.yoga,
+  [HKWorkoutActivityType.barre]: WorkoutActivityType.barre,
+  [HKWorkoutActivityType.coreTraining]: WorkoutActivityType.coreTraining,
+  [HKWorkoutActivityType.crossCountrySkiing]: WorkoutActivityType.crossCountrySkiing,
+  [HKWorkoutActivityType.downhillSkiing]: WorkoutActivityType.downhillSkiing,
+  [HKWorkoutActivityType.flexibility]: WorkoutActivityType.flexibility,
+  [HKWorkoutActivityType.highIntensityIntervalTraining]: WorkoutActivityType.highIntensityIntervalTraining,
+  [HKWorkoutActivityType.jumpRope]: WorkoutActivityType.jumpRope,
+  [HKWorkoutActivityType.kickboxing]: WorkoutActivityType.kickboxing,
+  [HKWorkoutActivityType.pilates]: WorkoutActivityType.pilates,
+  [HKWorkoutActivityType.snowboarding]: WorkoutActivityType.snowboarding,
+  [HKWorkoutActivityType.stairs]: WorkoutActivityType.stairs,
+  [HKWorkoutActivityType.stepTraining]: WorkoutActivityType.stepTraining,
+  [HKWorkoutActivityType.wheelchairWalkPace]: WorkoutActivityType.wheelchairWalkPace,
+  [HKWorkoutActivityType.wheelchairRunPace]: WorkoutActivityType.wheelchairRunPace,
+  [HKWorkoutActivityType.taiChi]: WorkoutActivityType.taiChi,
+  [HKWorkoutActivityType.mixedCardio]: WorkoutActivityType.mixedCardio,
+  [HKWorkoutActivityType.handCycling]: WorkoutActivityType.handCycling,
+  [HKWorkoutActivityType.discSports]: WorkoutActivityType.discSports,
+  [HKWorkoutActivityType.fitnessGaming]: WorkoutActivityType.fitnessGaming,
+  [HKWorkoutActivityType.cardioDance]: WorkoutActivityType.cardioDance,
+  [HKWorkoutActivityType.socialDance]: WorkoutActivityType.socialDance,
+  [HKWorkoutActivityType.pickleball]: WorkoutActivityType.pickleball,
+  [HKWorkoutActivityType.cooldown]: WorkoutActivityType.cooldown,
+  [HKWorkoutActivityType.swimBikeRun]: WorkoutActivityType.swimBikeRun,
+  [HKWorkoutActivityType.transition]: WorkoutActivityType.transition,
+  [HKWorkoutActivityType.underwaterDiving]: WorkoutActivityType.underwaterDiving,
+  [HKWorkoutActivityType.other]: WorkoutActivityType.other,
+};
+
+const SLEEP_STAGE_MAP: Record<number, SleepStage> = {
+  0: SleepStage.Unknown,   // HKCategoryValueSleepAnalysis.inBed
+  1: SleepStage.Unknown,   // asleepUnspecified
+  2: SleepStage.Awake,     // awake
+  3: SleepStage.Light,     // asleepCore
+  4: SleepStage.Deep,      // asleepDeep
+  5: SleepStage.REM,       // asleepREM
+};
+
+const dateFilter = (startDate: Date, endDate: Date) => ({
+  filter: { date: { startDate, endDate } },
+});
+
+export class HealthKitProvider implements HealthProvider {
+  async isAvailable(): Promise<boolean> {
+    return Healthkit.isHealthDataAvailable();
+  }
+
+  async shouldRequestAuthorization(dataTypes: HealthDataType[]): Promise<boolean> {
+    const readIdentifiers = dataTypes
+      .map((dt) => TYPE_MAP[dt]?.identifier)
+      .filter((id): id is HKIdentifier => id !== undefined);
+    const status = await Healthkit.getRequestStatusForAuthorization({
+      toRead: [...readIdentifiers, 'HKWorkoutTypeIdentifier'],
+    });
+    // status 1 = shouldRequest, 2 = unnecessary (already granted)
+    return status === 1;
+  }
+
+  async requestAuthorization(dataTypes: HealthDataType[]): Promise<boolean> {
+    const readIdentifiers = dataTypes
+      .map((dt) => TYPE_MAP[dt]?.identifier)
+      .filter((id): id is HKIdentifier => id !== undefined);
+    try {
+      await Healthkit.requestAuthorization({ toRead: [...readIdentifiers, 'HKWorkoutTypeIdentifier'] });
+      return true;
+    } catch {
+      return false;
+    } finally {
+      await setPermissionsRequested();
+    }
+  }
+
+  async getPermissionStatus(): Promise<PermissionStatus> {
+    try {
+      const wasRequested = await getPermissionsRequested();
+      if (!wasRequested) return PermissionStatus.UNKNOWN;
+
+      // On iOS, HealthKit does not expose read-permission denial status.
+      // getRequestStatusForAuthorization returns status 1 ("shouldRequest") for
+      // both genuine denials AND newly added data types that haven't been requested
+      // yet. Since we can't distinguish the two, and HealthKit silently returns
+      // empty data for denied types (the app still functions), we treat any
+      // previously-requested state as GRANTED. This prevents app updates that add
+      // new HealthDataTypes from incorrectly blocking all health data access.
+      return PermissionStatus.GRANTED;
+    } catch {
+      return PermissionStatus.UNKNOWN;
+    }
+  }
+
+  async querySamples(
+    type: HealthDataType,
+    startDate: Date,
+    endDate: Date,
+  ): Promise<HealthSample[]> {
+    const mapping = TYPE_MAP[type];
+    if (!mapping) return [];
+
+    if (mapping.isCategory) {
+      return this.queryCategorySamples(type, mapping, startDate, endDate);
+    }
+
+    const results = await Healthkit.queryQuantitySamples(
+      mapping.identifier as QuantityTypeIdentifier,
+      { limit: 0, ...dateFilter(startDate, endDate) },
+    );
+
+    return results.map((sample) => ({
+      type,
+      value: sample.quantity,
+      unit: mapping.unit,
+      startDate: new Date(sample.startDate),
+      endDate: new Date(sample.endDate),
+      sourceName: sample.sourceRevision?.source?.name ?? undefined,
+    }));
+  }
+
+  async queryAggregated(
+    type: HealthDataType,
+    startDate: Date,
+    endDate: Date,
+  ): Promise<HealthAggregate> {
+    const mapping = TYPE_MAP[type];
+    if (!mapping) return { type, unit: '', startDate, endDate };
+
+    if (mapping.isCategory) {
+      return this.aggregateCategorySamples(type, mapping, startDate, endDate);
+    }
+
+    const identifier = mapping.identifier as QuantityTypeIdentifier;
+    const options: StatisticsOptions[] = [
+      'cumulativeSum',
+      'discreteAverage',
+      'discreteMin',
+      'discreteMax',
+    ];
+
+    const result = await Healthkit.queryStatisticsForQuantity(
+      identifier,
+      options,
+      dateFilter(startDate, endDate),
+    );
+
+    return {
+      type,
+      sum: result.sumQuantity?.quantity,
+      avg: result.averageQuantity?.quantity,
+      min: result.minimumQuantity?.quantity,
+      max: result.maximumQuantity?.quantity,
+      unit: mapping.unit,
+      startDate,
+      endDate,
+    };
+  }
+
+  async queryWorkouts(startDate: Date, endDate: Date): Promise<Workout[]> {
+    const workoutProxies = await Healthkit.queryWorkoutSamples({
+      limit: 0,
+      ascending: false,
+      filter: { date: { startDate, endDate } },
+    });
+
+    const workouts = await Promise.all(
+      workoutProxies.map(async (proxy) => {
+        const workoutType =
+          WORKOUT_TYPE_MAP[proxy.workoutActivityType] ?? WorkoutActivityType.other;
+
+        let heartRateAvg: number | null = null;
+        let heartRateMax: number | null = null;
+
+        try {
+          const hrStats = await proxy.getStatistic(
+            'HKQuantityTypeIdentifierHeartRate',
+            'count/min',
+          );
+          if (hrStats) {
+            heartRateAvg = hrStats.averageQuantity?.quantity ?? null;
+            heartRateMax = hrStats.maximumQuantity?.quantity ?? null;
+          }
+        } catch {
+          // HR stats not available for this workout
+        }
+
+        const rawEnergy = proxy.totalEnergyBurned?.quantity;
+        const rawDistance = proxy.totalDistance?.quantity;
+
+        return {
+          workoutType,
+          duration: proxy.duration.quantity,
+          energyBurned: rawEnergy != null && !Number.isNaN(rawEnergy) ? rawEnergy : null,
+          distance: rawDistance != null && !Number.isNaN(rawDistance) ? rawDistance : null,
+          heartRateAvg,
+          heartRateMax,
+          startDate: new Date(proxy.startDate),
+          endDate: new Date(proxy.endDate),
+          sourceName: proxy.sourceRevision?.source?.name ?? 'Unknown',
+        };
+      }),
+    );
+
+    return workouts;
+  }
+
+  private async queryCategorySamples(
+    type: HealthDataType,
+    mapping: TypeMapping,
+    startDate: Date,
+    endDate: Date,
+  ): Promise<SleepStageSample[]> {
+    const results = await Healthkit.queryCategorySamples(
+      mapping.identifier as CategoryTypeIdentifier,
+      { limit: 0, ...dateFilter(startDate, endDate) },
+    );
+
+    return results.map((sample) => {
+      const start = new Date(sample.startDate);
+      const end = new Date(sample.endDate);
+      const durationHours =
+        (end.getTime() - start.getTime()) / (1000 * 60 * 60);
+
+      return {
+        type,
+        value: durationHours,
+        unit: mapping.unit,
+        startDate: start,
+        endDate: end,
+        sourceName: sample.sourceRevision?.source?.name ?? undefined,
+        stage: SLEEP_STAGE_MAP[sample.value] ?? SleepStage.Unknown,
+      };
+    });
+  }
+
+  async querySleepSessions(
+    startDate: Date,
+    endDate: Date,
+  ): Promise<SleepSession[]> {
+    const mapping = TYPE_MAP[HealthDataType.SleepAnalysis];
+    if (!mapping) return [];
+
+    const samples = await this.queryCategorySamples(
+      HealthDataType.SleepAnalysis,
+      mapping,
+      startDate,
+      endDate,
+    );
+
+    // Group samples into sessions: samples within 30 minutes of each other
+    // from the same source form one session
+    const sessions: SleepSession[] = [];
+    const sortedSamples = [...samples].sort(
+      (a, b) => a.startDate.getTime() - b.startDate.getTime(),
+    );
+
+    let currentGroup: SleepStageSample[] = [];
+    let currentSource: string | undefined;
+
+    for (const sample of sortedSamples) {
+      const lastInGroup = currentGroup[currentGroup.length - 1];
+      const sameSource = sample.sourceName === currentSource;
+      const withinWindow =
+        lastInGroup &&
+        sample.startDate.getTime() - lastInGroup.endDate.getTime() <=
+          30 * 60 * 1000; // 30 minutes
+
+      if (currentGroup.length === 0 || (sameSource && withinWindow)) {
+        currentGroup.push(sample);
+        currentSource = sample.sourceName;
+      } else {
+        sessions.push(this.buildSleepSession(currentGroup));
+        currentGroup = [sample];
+        currentSource = sample.sourceName;
+      }
+    }
+
+    if (currentGroup.length > 0) {
+      sessions.push(this.buildSleepSession(currentGroup));
+    }
+
+    return sessions;
+  }
+
+  private buildSleepSession(samples: SleepStageSample[]): SleepSession {
+    const stages = {
+      awake: 0,
+      light: 0,
+      deep: 0,
+      rem: 0,
+      unknown: 0,
+    };
+
+    for (const sample of samples) {
+      const hours = sample.value;
+      switch (sample.stage) {
+        case SleepStage.Awake:
+          stages.awake += hours;
+          break;
+        case SleepStage.Light:
+          stages.light += hours;
+          break;
+        case SleepStage.Deep:
+          stages.deep += hours;
+          break;
+        case SleepStage.REM:
+          stages.rem += hours;
+          break;
+        default:
+          stages.unknown += hours;
+          break;
+      }
+    }
+
+    const totalDuration = stages.light + stages.deep + stages.rem + stages.unknown;
+
+    return {
+      startDate: samples[0].startDate,
+      endDate: samples[samples.length - 1].endDate,
+      totalDuration,
+      stages,
+      sourceName: samples[0].sourceName ?? 'Unknown',
+    };
+  }
+
+  private async aggregateCategorySamples(
+    type: HealthDataType,
+    mapping: TypeMapping,
+    startDate: Date,
+    endDate: Date,
+  ): Promise<HealthAggregate> {
+    const samples = await this.queryCategorySamples(
+      type,
+      mapping,
+      startDate,
+      endDate,
+    );
+    const values = samples.map((s) => s.value);
+    const sum = values.reduce((a, b) => a + b, 0);
+
+    return {
+      type,
+      sum,
+      avg: values.length > 0 ? sum / values.length : undefined,
+      min: values.length > 0 ? values.reduce((a, b) => a < b ? a : b) : undefined,
+      max: values.length > 0 ? values.reduce((a, b) => a > b ? a : b) : undefined,
+      unit: mapping.unit,
+      startDate,
+      endDate,
+    };
+  }
+}

package/src/storage.ts

@@ -0,0 +1,85 @@
+declare const require: (mod: string) => any;
+
+const STORAGE_KEY = 'permissions_requested';
+const LEGACY_ASYNC_STORAGE_KEY = '@robin_health_sdk:permissions_requested';
+const DB_NAME = 'robin_health_sdk.db';
+const TABLE = 'kv';
+
+type SQLiteDb = {
+  execSync: (sql: string) => void;
+  getFirstSync: <T>(sql: string, params: unknown[]) => T | null;
+  runSync: (sql: string, params: unknown[]) => void;
+};
+
+let db: SQLiteDb | null = null;
+let migrationDone = false;
+
+try {
+  const SQLite = require('expo-sqlite');
+  db = SQLite.openDatabaseSync(DB_NAME) as SQLiteDb;
+  db.execSync(
+    `CREATE TABLE IF NOT EXISTS ${TABLE} (key TEXT PRIMARY KEY, value TEXT NOT NULL)`,
+  );
+} catch {
+  // expo-sqlite not available — getPermissionStatus will always return UNKNOWN
+}
+
+function getFromDb(key: string): string | null {
+  if (!db) return null;
+  const row = db.getFirstSync<{ value: string }>(
+    `SELECT value FROM ${TABLE} WHERE key = ?`,
+    [key],
+  );
+  return row?.value ?? null;
+}
+
+function setInDb(key: string, value: string): void {
+  if (!db) return;
+  db.runSync(
+    `INSERT OR REPLACE INTO ${TABLE} (key, value) VALUES (?, ?)`,
+    [key, value],
+  );
+}
+
+/**
+ * One-time migration from legacy AsyncStorage to SQLite.
+ * Runs at most once per app session. If AsyncStorage is not installed
+ * or the legacy key doesn't exist, this is a no-op.
+ */
+async function migrateFromAsyncStorage(): Promise<void> {
+  if (migrationDone || !db) return;
+  migrationDone = true;
+
+  // Already have a value in SQLite — no migration needed
+  if (getFromDb(STORAGE_KEY) !== null) return;
+
+  try {
+    const AsyncStorage = require('@react-native-async-storage/async-storage').default;
+    const legacy = await AsyncStorage.getItem(LEGACY_ASYNC_STORAGE_KEY);
+    if (legacy === 'true') {
+      setInDb(STORAGE_KEY, 'true');
+      await AsyncStorage.removeItem(LEGACY_ASYNC_STORAGE_KEY);
+    }
+  } catch {
+    // AsyncStorage not installed or migration failed — not critical
+  }
+}
+
+export async function getPermissionsRequested(): Promise<boolean> {
+  try {
+    if (!db) return false;
+    await migrateFromAsyncStorage();
+    return getFromDb(STORAGE_KEY) === 'true';
+  } catch {
+    return false;
+  }
+}
+
+export async function setPermissionsRequested(): Promise<void> {
+  try {
+    if (!db) return;
+    setInDb(STORAGE_KEY, 'true');
+  } catch {
+    // Swallow — worst case next call returns UNKNOWN
+  }
+}