@ateam-ai-mobile/expo 0.1.4 → 0.1.7

package/dist/device-bridge/index.js

@@ -0,0 +1,2084 @@
+"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/device-bridge/index.ts
+var device_bridge_exports = {};
+__export(device_bridge_exports, {
+  BACKGROUND_TASK_NAME: () => BACKGROUND_TASK_NAME,
+  DeviceBridge: () => DeviceBridge,
+  QueuePoller: () => QueuePoller,
+  RelayClient: () => RelayClient,
+  biometrics: () => biometrics_exports,
+  capabilities: () => capabilities_exports,
+  location: () => location_exports,
+  registerBackgroundSync: () => registerBackgroundSync,
+  scanner: () => scanner_exports,
+  sharing: () => sharing_exports,
+  syncDomains: () => syncDomains,
+  unregisterBackgroundSync: () => unregisterBackgroundSync
+});
+module.exports = __toCommonJS(device_bridge_exports);
+
+// src/device-bridge/relay-client.ts
+var RelayClient = class {
+  constructor(config) {
+    this.offlineQueue = [];
+    this.baseUrl = config.relayUrl.replace(/\/$/, "");
+    this.deviceId = config.deviceId;
+    this.tenant = config.tenant;
+    this.actorId = config.actorId ?? "default";
+    this.apiKey = config.apiKey ?? "";
+    this.timeout = config.timeout ?? 1e4;
+  }
+  // ─── Data Sync ───
+  /**
+   * Push a full device data bundle to the relay.
+   * If offline, buffers the bundle and retries on next sync.
+   */
+  async pushData(bundle) {
+    try {
+      const response = await this.fetch(
+        `/api/device/${this.deviceId}/sync`,
+        {
+          method: "POST",
+          body: JSON.stringify(bundle)
+        }
+      );
+      if (response.ok) {
+        await this.flushOfflineQueue();
+        return { ok: true };
+      }
+      return {
+        ok: false,
+        error: `Relay returned ${response.status}: ${await response.text()}`
+      };
+    } catch (error) {
+      this.offlineQueue.push(bundle);
+      return {
+        ok: false,
+        error: `Offline \u2014 buffered (${this.offlineQueue.length} pending)`
+      };
+    }
+  }
+  /**
+   * Push a single domain update (partial sync).
+   */
+  async pushDomain(domain, data) {
+    try {
+      const response = await this.fetch(
+        `/api/device/${this.deviceId}/sync/${domain}`,
+        {
+          method: "POST",
+          body: JSON.stringify({ domain, data, timestamp: (/* @__PURE__ */ new Date()).toISOString(), actorId: this.actorId })
+        }
+      );
+      if (response.ok) return { ok: true };
+      return {
+        ok: false,
+        error: `Relay returned ${response.status}`
+      };
+    } catch (error) {
+      return { ok: false, error: "Network error \u2014 domain sync failed" };
+    }
+  }
+  // ─── Action Queue ───
+  /**
+   * Poll for pending actions the phone needs to execute.
+   */
+  async pollActions() {
+    try {
+      const response = await this.fetch(
+        `/api/device/${this.deviceId}/actions`,
+        { method: "GET" }
+      );
+      if (response.ok) {
+        const data = await response.json();
+        return { ok: true, data: data.actions ?? [] };
+      }
+      return { ok: false, error: `Relay returned ${response.status}` };
+    } catch (error) {
+      return { ok: false, error: "Network error \u2014 action poll failed" };
+    }
+  }
+  /**
+   * Report action execution result and remove from queue.
+   */
+  async completeAction(result) {
+    try {
+      const response = await this.fetch(
+        `/api/device/${this.deviceId}/actions/${result.id}`,
+        {
+          method: "DELETE",
+          body: JSON.stringify(result)
+        }
+      );
+      if (response.ok) return { ok: true };
+      return { ok: false, error: `Relay returned ${response.status}` };
+    } catch (error) {
+      return { ok: false, error: "Network error \u2014 action complete failed" };
+    }
+  }
+  // ─── Health ───
+  /**
+   * Ping the relay to check connectivity.
+   */
+  async ping() {
+    try {
+      const response = await this.fetch(
+        `/api/health`,
+        { method: "GET" },
+        3e3
+        // short timeout for health check
+      );
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get count of buffered offline bundles.
+   */
+  getOfflineQueueSize() {
+    return this.offlineQueue.length;
+  }
+  // ─── Internal ───
+  async fetch(path, init, timeout) {
+    const controller = new AbortController();
+    const timer = setTimeout(
+      () => controller.abort(),
+      timeout ?? this.timeout
+    );
+    try {
+      return await fetch(`${this.baseUrl}${path}`, {
+        ...init,
+        signal: controller.signal,
+        headers: {
+          "Content-Type": "application/json",
+          "X-ADAS-TENANT": this.tenant,
+          "X-ADAS-ACTOR": this.actorId,
+          "X-Device-Id": this.deviceId,
+          // The relay (post-2026-04-25) gates every /api/device/* call on
+          // a shared secret. Send it as `Authorization: Bearer` so the
+          // server's relayAuth middleware accepts the request. Empty/missing
+          // secret = 401 from the relay (correct fail-closed behavior).
+          ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {},
+          ...init.headers || {}
+        }
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async flushOfflineQueue() {
+    if (this.offlineQueue.length === 0) return;
+    const queue = [...this.offlineQueue];
+    this.offlineQueue = [];
+    for (const bundle of queue) {
+      try {
+        const response = await this.fetch(
+          `/api/device/${this.deviceId}/sync`,
+          {
+            method: "POST",
+            body: JSON.stringify(bundle)
+          }
+        );
+        if (!response.ok) {
+          this.offlineQueue.push(bundle);
+        }
+      } catch {
+        this.offlineQueue.push(bundle);
+        break;
+      }
+    }
+  }
+};
+
+// src/device-bridge/actions/messaging.ts
+var SMS = __toESM(require("expo-sms"));
+async function execute(actionId, params) {
+  const phone = params.phone;
+  const message = params.message;
+  if (!phone || !message) {
+    return {
+      id: actionId,
+      ok: false,
+      error: "Missing phone or message parameter",
+      executed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  try {
+    const available = await SMS.isAvailableAsync();
+    if (!available) {
+      return {
+        id: actionId,
+        ok: false,
+        error: "SMS not available on this device",
+        executed_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    const { result } = await SMS.sendSMSAsync([phone], message);
+    return {
+      id: actionId,
+      ok: result === "sent" || result === "unknown",
+      // 'unknown' on Android means it was sent
+      result: {
+        to: params.contact_name || phone,
+        phone,
+        message,
+        status: result,
+        sent_at: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      executed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch (error) {
+    return {
+      id: actionId,
+      ok: false,
+      error: `SMS send failed: ${error instanceof Error ? error.message : String(error)}`,
+      executed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+}
+
+// src/device-bridge/actions/calendar-actions.ts
+var ExpoCalendar = __toESM(require("expo-calendar"));
+async function getDefaultCalendarId() {
+  const calendars = await ExpoCalendar.getCalendarsAsync(ExpoCalendar.EntityTypes.EVENT);
+  const defaultCal = calendars.find((c) => c.isPrimary) || calendars[0];
+  return defaultCal?.id || null;
+}
+async function executeCreate(actionId, params) {
+  const title = params.title;
+  const date = params.date;
+  const startTime = params.start_time;
+  const endTime = params.end_time;
+  if (!title || !date || !startTime) {
+    return {
+      id: actionId,
+      ok: false,
+      error: "Missing title, date, or start_time",
+      executed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  try {
+    const calendarId = await getDefaultCalendarId();
+    if (!calendarId) {
+      return {
+        id: actionId,
+        ok: false,
+        error: "No calendar found on device",
+        executed_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+    const [year, month, day] = date.split("-").map(Number);
+    const [startH, startM] = startTime.split(":").map(Number);
+    const startDate = new Date(year, month - 1, day, startH, startM);
+    let endDate;
+    if (endTime) {
+      const [endH, endM] = endTime.split(":").map(Number);
+      endDate = new Date(year, month - 1, day, endH, endM);
+    } else {
+      endDate = new Date(startDate.getTime() + 60 * 60 * 1e3);
+    }
+    const eventId = await ExpoCalendar.createEventAsync(calendarId, {
+      title,
+      startDate,
+      endDate,
+      location: params.location || void 0,
+      notes: params.notes || void 0,
+      timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone
+    });
+    return {
+      id: actionId,
+      ok: true,
+      result: {
+        event_id: eventId,
+        title,
+        date,
+        start: startTime,
+        end: endTime || formatTime(endDate),
+        message: `Event "${title}" created successfully`
+      },
+      executed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch (error) {
+    return {
+      id: actionId,
+      ok: false,
+      error: `Calendar create failed: ${error instanceof Error ? error.message : String(error)}`,
+      executed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+}
+async function executeReschedule(actionId, params) {
+  const eventId = params.event_id;
+  if (!eventId) {
+    return {
+      id: actionId,
+      ok: false,
+      error: "Missing event_id",
+      executed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  try {
+    const updates = {};
+    if (params.new_date && params.new_start_time) {
+      const [year, month, day] = params.new_date.split("-").map(Number);
+      const [h, m] = params.new_start_time.split(":").map(Number);
+      updates.startDate = new Date(year, month - 1, day, h, m);
+      if (params.new_end_time) {
+        const [eh, em] = params.new_end_time.split(":").map(Number);
+        updates.endDate = new Date(year, month - 1, day, eh, em);
+      } else {
+        updates.endDate = new Date(updates.startDate.getTime() + 60 * 60 * 1e3);
+      }
+    }
+    await ExpoCalendar.updateEventAsync(eventId, updates);
+    return {
+      id: actionId,
+      ok: true,
+      result: { event_id: eventId, message: "Event rescheduled successfully" },
+      executed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch (error) {
+    return {
+      id: actionId,
+      ok: false,
+      error: `Calendar reschedule failed: ${error instanceof Error ? error.message : String(error)}`,
+      executed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+}
+async function executeCancel(actionId, params) {
+  const eventId = params.event_id;
+  if (!eventId) {
+    return {
+      id: actionId,
+      ok: false,
+      error: "Missing event_id",
+      executed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  try {
+    await ExpoCalendar.deleteEventAsync(eventId);
+    return {
+      id: actionId,
+      ok: true,
+      result: { event_id: eventId, message: "Event cancelled successfully" },
+      executed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch (error) {
+    return {
+      id: actionId,
+      ok: false,
+      error: `Calendar cancel failed: ${error instanceof Error ? error.message : String(error)}`,
+      executed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+}
+function formatTime(date) {
+  return date.toLocaleTimeString("en-US", {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  });
+}
+
+// src/device-bridge/actions/dnd.ts
+var currentDndState = {
+  enabled: false,
+  schedule: { start: "22:00", end: "07:00" },
+  allowlist: []
+};
+async function execute2(actionId, params) {
+  try {
+    if (params.enabled !== void 0) {
+      currentDndState.enabled = params.enabled;
+    }
+    if (params.schedule_start) {
+      currentDndState.schedule.start = params.schedule_start;
+    }
+    if (params.schedule_end) {
+      currentDndState.schedule.end = params.schedule_end;
+    }
+    if (params.allowlist) {
+      currentDndState.allowlist = params.allowlist;
+    }
+    return {
+      id: actionId,
+      ok: true,
+      result: {
+        message: `DND ${currentDndState.enabled ? "enabled" : "disabled"}`,
+        dnd: currentDndState
+      },
+      executed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch (error) {
+    return {
+      id: actionId,
+      ok: false,
+      error: `DND set failed: ${error instanceof Error ? error.message : String(error)}`,
+      executed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+}
+
+// src/device-bridge/actions/navigation.ts
+var Linking = __toESM(require("expo-linking"));
+var import_react_native = require("react-native");
+async function execute3(actionId, params) {
+  const destination = params.destination;
+  const mode = params.mode || "driving";
+  if (!destination) {
+    return {
+      id: actionId,
+      ok: false,
+      error: "Missing destination parameter",
+      executed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  try {
+    const encodedDest = encodeURIComponent(destination);
+    let url;
+    if (import_react_native.Platform.OS === "ios") {
+      const modeMap = {
+        driving: "d",
+        transit: "r",
+        walking: "w"
+      };
+      url = `maps://maps.apple.com/?daddr=${encodedDest}&dirflg=${modeMap[mode] || "d"}`;
+    } else {
+      const modeMap = {
+        driving: "driving",
+        transit: "transit",
+        walking: "walking"
+      };
+      url = `google.navigation:q=${encodedDest}&mode=${modeMap[mode] || "driving"}`;
+    }
+    const canOpen = await Linking.canOpenURL(url);
+    if (!canOpen) {
+      const webModeMap = {
+        driving: "driving",
+        transit: "transit",
+        walking: "walking"
+      };
+      url = `https://www.google.com/maps/dir/?api=1&destination=${encodedDest}&travelmode=${webModeMap[mode] || "driving"}`;
+    }
+    await Linking.openURL(url);
+    return {
+      id: actionId,
+      ok: true,
+      result: {
+        message: `Navigation started to ${destination} via ${mode}`,
+        destination,
+        mode,
+        status: "navigating"
+      },
+      executed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch (error) {
+    return {
+      id: actionId,
+      ok: false,
+      error: `Navigation failed: ${error instanceof Error ? error.message : String(error)}`,
+      executed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+}
+
+// src/device-bridge/collectors/health.ts
+var import_react_native2 = require("react-native");
+var _HK = null;
+var _hkProbed = false;
+function getHK() {
+  if (import_react_native2.Platform.OS !== "ios") return null;
+  if (_hkProbed) return _HK;
+  _hkProbed = true;
+  try {
+    const mod = require("@kingstinct/react-native-healthkit");
+    if (mod && typeof mod.requestAuthorization === "function") {
+      _HK = mod;
+    } else {
+      console.warn("[health] @kingstinct/react-native-healthkit native bridge unavailable \u2014 HealthKit disabled (Expo Go?)");
+    }
+  } catch (e) {
+    console.warn("[health] @kingstinct/react-native-healthkit require failed:", e);
+  }
+  return _HK;
+}
+var lastHealthInitError = null;
+var READ_TYPES = [
+  "HKQuantityTypeIdentifierStepCount",
+  "HKQuantityTypeIdentifierFlightsClimbed",
+  "HKQuantityTypeIdentifierActiveEnergyBurned",
+  "HKQuantityTypeIdentifierDistanceWalkingRunning",
+  // Added for mood signals — all read-only, covered by the same auth sheet.
+  "HKQuantityTypeIdentifierRestingHeartRate",
+  "HKQuantityTypeIdentifierAppleExerciseTime",
+  "HKCategoryTypeIdentifierSleepAnalysis"
+];
+var _initPromise = null;
+async function ensureInit() {
+  const HK = getHK();
+  if (!HK) {
+    lastHealthInitError = "@kingstinct/react-native-healthkit native module not loaded";
+    return false;
+  }
+  if (_initPromise) return _initPromise;
+  _initPromise = (async () => {
+    try {
+      await HK.requestAuthorization({ toRead: READ_TYPES, toWrite: [] });
+      lastHealthInitError = null;
+      return true;
+    } catch (e) {
+      lastHealthInitError = `requestAuthorization threw: ${e?.message || String(e)}`;
+      console.warn("[health]", lastHealthInitError);
+      _initPromise = null;
+      return false;
+    }
+  })();
+  return _initPromise;
+}
+async function hasPermission() {
+  return ensureInit();
+}
+async function requestPermission() {
+  return ensureInit();
+}
+function startOfDay(d) {
+  const out = new Date(d);
+  out.setHours(0, 0, 0, 0);
+  return out;
+}
+function dateKey(d) {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  return `${y}-${m}-${day}`;
+}
+async function readDailySum(identifier, unit, start, end) {
+  const HK = getHK();
+  if (!HK?.queryStatisticsForQuantity) return 0;
+  try {
+    const result = await HK.queryStatisticsForQuantity(
+      identifier,
+      ["cumulativeSum"],
+      {
+        unit,
+        filter: { date: { startDate: start, endDate: end } }
+      }
+    );
+    const q = result?.sumQuantity?.quantity;
+    return typeof q === "number" ? q : 0;
+  } catch {
+    return 0;
+  }
+}
+async function readDailyAverage(identifier, unit, start, end) {
+  const HK = getHK();
+  if (!HK?.queryStatisticsForQuantity) return null;
+  try {
+    const result = await HK.queryStatisticsForQuantity(
+      identifier,
+      ["discreteAverage"],
+      { unit, filter: { date: { startDate: start, endDate: end } } }
+    );
+    const q = result?.averageQuantity?.quantity;
+    return typeof q === "number" ? q : null;
+  } catch {
+    return null;
+  }
+}
+async function readSleepMinutes(start, end) {
+  const HK = getHK();
+  const query = HK?.queryCategorySamples || HK?.queryCategorySamplesAsync || HK?.querySamples;
+  if (!query) return null;
+  try {
+    const samples = await query.call(
+      HK,
+      "HKCategoryTypeIdentifierSleepAnalysis",
+      { filter: { date: { startDate: start, endDate: end } } }
+    );
+    if (!Array.isArray(samples) || samples.length === 0) return null;
+    let ms = 0;
+    for (const s of samples) {
+      const v = s?.value;
+      const isAsleep = v !== 0 && v !== 2;
+      if (!isAsleep) continue;
+      const a = new Date(s?.startDate).getTime();
+      const b = new Date(s?.endDate).getTime();
+      if (Number.isFinite(a) && Number.isFinite(b) && b > a) ms += b - a;
+    }
+    return ms > 0 ? Math.round(ms / 6e4) : null;
+  } catch {
+    return null;
+  }
+}
+async function collectMoodExtras() {
+  const ok = await ensureInit();
+  if (!ok) return { sleep_min: null, resting_hr: null, active_energy_kcal: null, exercise_min: null };
+  const start = startOfDay(/* @__PURE__ */ new Date());
+  const end = new Date(start);
+  end.setDate(end.getDate() + 1);
+  const sleepStart = new Date(start);
+  sleepStart.setHours(sleepStart.getHours() - 6);
+  const [sleep_min, resting_hr, energy, exercise] = await Promise.all([
+    readSleepMinutes(sleepStart, end),
+    readDailyAverage("HKQuantityTypeIdentifierRestingHeartRate", "count/min", start, end),
+    readDailySum("HKQuantityTypeIdentifierActiveEnergyBurned", "kcal", start, end),
+    readDailySum("HKQuantityTypeIdentifierAppleExerciseTime", "min", start, end)
+  ]);
+  return {
+    sleep_min,
+    resting_hr: resting_hr != null ? Math.round(resting_hr) : null,
+    active_energy_kcal: energy ? Math.round(energy) : null,
+    exercise_min: exercise ? Math.round(exercise) : null
+  };
+}
+async function readDay(date) {
+  const start = startOfDay(date);
+  const end = new Date(start);
+  end.setDate(end.getDate() + 1);
+  const [steps, floors, energy, distance] = await Promise.all([
+    readDailySum("HKQuantityTypeIdentifierStepCount", "count", start, end),
+    readDailySum("HKQuantityTypeIdentifierFlightsClimbed", "count", start, end),
+    readDailySum("HKQuantityTypeIdentifierActiveEnergyBurned", "kcal", start, end),
+    // Ask for kilometers directly so we don't have to convert from meters.
+    readDailySum("HKQuantityTypeIdentifierDistanceWalkingRunning", "km", start, end)
+  ]);
+  return {
+    date: dateKey(start),
+    available: true,
+    steps: Math.round(steps),
+    floors: Math.round(floors),
+    active_energy_kcal: Math.round(energy),
+    distance_km: Math.round(distance * 100) / 100
+  };
+}
+function unavailableDay(date) {
+  return {
+    date: dateKey(date),
+    available: false,
+    steps: null,
+    floors: null,
+    active_energy_kcal: null,
+    distance_km: null
+  };
+}
+async function collectToday() {
+  const ok = await ensureInit();
+  if (!ok) {
+    return unavailableDay(/* @__PURE__ */ new Date());
+  }
+  return readDay(/* @__PURE__ */ new Date());
+}
+async function collectHistory(days) {
+  const n = Math.max(1, Math.min(30, Math.floor(days)));
+  const ok = await ensureInit();
+  if (!ok) return [];
+  const today = startOfDay(/* @__PURE__ */ new Date());
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const d = new Date(today);
+    d.setDate(d.getDate() - i);
+    out.push(await readDay(d));
+  }
+  return out;
+}
+
+// src/device-bridge/actions/health-actions.ts
+async function executeToday(actionId) {
+  try {
+    const today = await collectToday();
+    return {
+      id: actionId,
+      ok: true,
+      result: { today },
+      executed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch (e) {
+    return {
+      id: actionId,
+      ok: false,
+      error: String(e?.message || e),
+      executed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+}
+async function executeHistory(actionId, params) {
+  try {
+    const days = Number(params?.days) || 30;
+    const list = await collectHistory(days);
+    return {
+      id: actionId,
+      ok: true,
+      result: { days: list },
+      executed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch (e) {
+    return {
+      id: actionId,
+      ok: false,
+      error: String(e?.message || e),
+      executed_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+}
+
+// src/device-bridge/actions/queue-poller.ts
+var QueuePoller = class {
+  constructor(config) {
+    this.timer = null;
+    this.running = false;
+    this.relayClient = config.relayClient;
+    this.pollInterval = config.pollInterval ?? 5e3;
+    this.onActionExecuted = config.onActionExecuted;
+    this.onError = config.onError;
+  }
+  /**
+   * Start polling for actions.
+   */
+  start() {
+    if (this.running) return;
+    this.running = true;
+    this.poll();
+    this.timer = setInterval(() => this.poll(), this.pollInterval);
+  }
+  /**
+   * Stop polling.
+   */
+  stop() {
+    this.running = false;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  /**
+   * Check if poller is running.
+   */
+  isRunning() {
+    return this.running;
+  }
+  /**
+   * Execute a single poll cycle.
+   */
+  async poll() {
+    if (!this.running) return;
+    try {
+      const response = await this.relayClient.pollActions();
+      if (!response.ok || !response.data) return;
+      for (const action of response.data) {
+        if (action.status && action.status !== "pending") continue;
+        const result = await this.executeAction(action);
+        await this.relayClient.completeAction(result);
+        this.onActionExecuted?.(result);
+      }
+    } catch (error) {
+      this.onError?.(
+        error instanceof Error ? error : new Error(String(error))
+      );
+    }
+  }
+  /**
+   * Route an action to the appropriate executor.
+   */
+  async executeAction(action) {
+    const { id, type, params } = action;
+    try {
+      switch (type) {
+        case "messaging.send":
+          return await execute(id, params);
+        case "calendar.create":
+          return await executeCreate(id, params);
+        case "calendar.reschedule":
+          return await executeReschedule(id, params);
+        case "calendar.cancel":
+          return await executeCancel(id, params);
+        case "dnd.set":
+          return await execute2(id, params);
+        case "navigation.start":
+          return await execute3(id, params);
+        case "health.today":
+          return await executeToday(id);
+        case "health.history":
+          return await executeHistory(id, params);
+        default:
+          return {
+            id,
+            ok: false,
+            error: `Unknown action type: ${type}`,
+            executed_at: (/* @__PURE__ */ new Date()).toISOString()
+          };
+      }
+    } catch (error) {
+      return {
+        id,
+        ok: false,
+        error: `Action execution failed: ${error instanceof Error ? error.message : String(error)}`,
+        executed_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+    }
+  }
+};
+
+// src/device-bridge/background.ts
+var TaskManager = __toESM(require("expo-task-manager"));
+var BackgroundFetch = __toESM(require("expo-background-fetch"));
+
+// src/device-bridge/capabilities.ts
+var capabilities_exports = {};
+__export(capabilities_exports, {
+  allBuiltIn: () => allBuiltIn,
+  batteryCapability: () => batteryCapability,
+  calendarCapability: () => calendarCapability,
+  cameraCapability: () => cameraCapability,
+  connectivityCapability: () => connectivityCapability,
+  contactsCapability: () => contactsCapability,
+  healthCapability: () => healthCapability,
+  locationCapability: () => locationCapability,
+  moodCapability: () => moodCapability,
+  notificationsCapability: () => notificationsCapability
+});
+
+// src/device-bridge/collectors/calendar.ts
+var ExpoCalendar2 = __toESM(require("expo-calendar"));
+async function requestPermission2() {
+  const { status } = await ExpoCalendar2.requestCalendarPermissionsAsync();
+  return status === "granted";
+}
+async function hasPermission2() {
+  const { status } = await ExpoCalendar2.getCalendarPermissionsAsync();
+  return status === "granted";
+}
+async function collectToday2() {
+  const now = /* @__PURE__ */ new Date();
+  const startOfDay2 = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  const endOfDay = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 23, 59, 59);
+  const calendars = await ExpoCalendar2.getCalendarsAsync(ExpoCalendar2.EntityTypes.EVENT);
+  const userCalendarIds = getUserCalendarIds(calendars);
+  const events = await ExpoCalendar2.getEventsAsync(userCalendarIds, startOfDay2, endOfDay);
+  const filtered = filterHolidays(events);
+  const mapped = filtered.map((e) => ({
+    id: e.id,
+    title: e.title || "Untitled",
+    date: startOfDay2.toISOString().slice(0, 10),
+    start: formatTime2(new Date(e.startDate)),
+    end: formatTime2(new Date(e.endDate)),
+    location: e.location || "",
+    attendees: (e.attendees || []).map((a) => a.name || a.email || "Unknown"),
+    notes: e.notes || ""
+  }));
+  mapped.sort((a, b) => a.start.localeCompare(b.start));
+  return {
+    ok: true,
+    date: startOfDay2.toISOString().slice(0, 10),
+    day_of_week: now.toLocaleDateString("en-US", { weekday: "long" }),
+    event_count: mapped.length,
+    events: mapped
+  };
+}
+async function collectUpcoming(daysAhead = 3) {
+  const now = /* @__PURE__ */ new Date();
+  const tomorrow = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1);
+  const endDate = new Date(now.getFullYear(), now.getMonth(), now.getDate() + daysAhead + 1);
+  const calendars = await ExpoCalendar2.getCalendarsAsync(ExpoCalendar2.EntityTypes.EVENT);
+  const userCalendarIds = getUserCalendarIds(calendars);
+  const events = await ExpoCalendar2.getEventsAsync(userCalendarIds, tomorrow, endDate);
+  const filtered = filterHolidays(events);
+  const mapped = filtered.map((e) => {
+    const startDt = new Date(e.startDate);
+    return {
+      id: e.id,
+      title: e.title || "Untitled",
+      date: startDt.toISOString().slice(0, 10),
+      start: formatTime2(startDt),
+      end: formatTime2(new Date(e.endDate)),
+      location: e.location || "",
+      attendees: (e.attendees || []).map((a) => a.name || a.email || "Unknown"),
+      notes: e.notes || ""
+    };
+  });
+  mapped.sort(
+    (a, b) => a.date === b.date ? a.start.localeCompare(b.start) : a.date.localeCompare(b.date)
+  );
+  return {
+    ok: true,
+    from: tomorrow.toISOString().slice(0, 10),
+    days_ahead: daysAhead,
+    event_count: mapped.length,
+    events: mapped
+  };
+}
+function getUserCalendarIds(calendars) {
+  const SKIP_SOURCES = ["birthdays", "other"];
+  const SKIP_TYPES = ["birthdays", "other"];
+  return calendars.filter((c) => {
+    const sourceType = (c.source?.type || "").toLowerCase();
+    const calType = (c.type || "").toLowerCase();
+    if (SKIP_SOURCES.includes(sourceType)) return false;
+    if (SKIP_TYPES.includes(calType)) return false;
+    return true;
+  }).map((c) => c.id);
+}
+function filterHolidays(events) {
+  const HOLIDAY_PATTERNS = [
+    /holiday/i,
+    /observance/i,
+    /eve\b.*\btentative\b/i,
+    /\btentative\b/i
+  ];
+  return events.filter((e) => {
+    const isAllDay = e.allDay === true;
+    const notes = (e.notes || "").toLowerCase();
+    if (isAllDay && HOLIDAY_PATTERNS.some((p) => p.test(notes))) return false;
+    if (isAllDay && HOLIDAY_PATTERNS.some((p) => p.test(e.title || ""))) return false;
+    return true;
+  });
+}
+function formatTime2(date) {
+  return date.toLocaleTimeString("en-US", {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  });
+}
+
+// src/device-bridge/collectors/contacts.ts
+var ExpoContacts = __toESM(require("expo-contacts"));
+var import_async_storage = __toESM(require("@react-native-async-storage/async-storage"));
+var HASH_STORE_KEY = "device-bridge.contacts.hashes.v1";
+async function requestPermission3() {
+  const { status } = await ExpoContacts.requestPermissionsAsync();
+  return status === "granted";
+}
+async function hasPermission3() {
+  const { status } = await ExpoContacts.getPermissionsAsync();
+  return status === "granted";
+}
+var lastContactsStats = null;
+async function collectAll() {
+  const result = await ExpoContacts.getContactsAsync({
+    fields: [
+      ExpoContacts.Fields.Name,
+      ExpoContacts.Fields.PhoneNumbers,
+      ExpoContacts.Fields.Emails,
+      ExpoContacts.Fields.Birthday
+    ],
+    sort: ExpoContacts.SortTypes.LastName
+  });
+  const raw = Array.isArray(result?.data) ? result.data : [];
+  const contacts = [];
+  const currentHashes = {};
+  for (let i = 0; i < raw.length; i++) {
+    const c = raw[i];
+    const id = c.id || `c${i}`;
+    const mapped = {
+      id,
+      name: c.name || `${c.firstName || ""} ${c.lastName || ""}`.trim() || "Unknown",
+      relationship: "",
+      // dropped — was the iOS Unauthorized-Keys trigger
+      phone: c.phoneNumbers?.[0]?.number || null,
+      email: c.emails?.[0]?.email || null,
+      birthday: formatBirthday(c.birthday),
+      notes: ""
+      // dropped — Notes is restricted on iOS 16+
+    };
+    contacts.push(mapped);
+    currentHashes[id] = hashContact(mapped);
+  }
+  let stored = {};
+  try {
+    const blob = await import_async_storage.default.getItem(HASH_STORE_KEY);
+    if (blob) stored = JSON.parse(blob);
+  } catch {
+  }
+  const fullSync = Object.keys(stored).length === 0;
+  let added = 0;
+  let updated = 0;
+  let unchanged = 0;
+  for (const id of Object.keys(currentHashes)) {
+    const prev = stored[id];
+    if (prev === void 0) added++;
+    else if (prev !== currentHashes[id]) updated++;
+    else unchanged++;
+  }
+  let removed = 0;
+  for (const id of Object.keys(stored)) {
+    if (currentHashes[id] === void 0) removed++;
+  }
+  lastContactsStats = {
+    total: contacts.length,
+    added,
+    updated,
+    removed,
+    unchanged,
+    full_sync: fullSync
+  };
+  if (!fullSync && added === 0 && updated === 0 && removed === 0) {
+    return null;
+  }
+  try {
+    await import_async_storage.default.setItem(HASH_STORE_KEY, JSON.stringify(currentHashes));
+  } catch {
+  }
+  return contacts;
+}
+function fnv1a(str) {
+  let h = 2166136261;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16).padStart(8, "0");
+}
+function hashContact(c) {
+  const parts = [
+    c.id,
+    (c.name || "").trim(),
+    c.phone || "\0",
+    (c.email || "\0").toLowerCase(),
+    c.birthday || "\0"
+  ];
+  return fnv1a(parts.join(""));
+}
+function formatBirthday(birthday) {
+  if (!birthday) return null;
+  const { year, month, day } = birthday;
+  if (month === void 0 || day === void 0) return null;
+  const m = String(month + 1).padStart(2, "0");
+  const d = String(day).padStart(2, "0");
+  if (!year) return `--${m}-${d}`;
+  return `${year}-${m}-${d}`;
+}
+
+// src/device-bridge/collectors/location.ts
+var location_exports = {};
+__export(location_exports, {
+  collectCurrent: () => collectCurrent,
+  getPosition: () => getPosition,
+  hasPermission: () => hasPermission4,
+  requestPermission: () => requestPermission4,
+  watchPosition: () => watchPosition
+});
+var ExpoLocation = __toESM(require("expo-location"));
+async function requestPermission4() {
+  const { status: fg } = await ExpoLocation.requestForegroundPermissionsAsync();
+  if (fg !== "granted") return false;
+  try {
+    await ExpoLocation.requestBackgroundPermissionsAsync();
+  } catch {
+  }
+  return fg === "granted";
+}
+async function hasPermission4() {
+  const { status } = await ExpoLocation.getForegroundPermissionsAsync();
+  return status === "granted";
+}
+async function collectCurrent() {
+  const location = await ExpoLocation.getCurrentPositionAsync({
+    accuracy: ExpoLocation.Accuracy.Balanced
+  });
+  let place = "Current Location";
+  let address = `${location.coords.latitude.toFixed(4)}, ${location.coords.longitude.toFixed(4)}`;
+  let locationType = "unknown";
+  try {
+    const [geocoded] = await ExpoLocation.reverseGeocodeAsync({
+      latitude: location.coords.latitude,
+      longitude: location.coords.longitude
+    });
+    if (geocoded) {
+      place = geocoded.name || geocoded.street || place;
+      address = [
+        geocoded.streetNumber,
+        geocoded.street,
+        geocoded.city,
+        geocoded.region
+      ].filter(Boolean).join(", ") || address;
+      locationType = classifyLocation(geocoded);
+    }
+  } catch {
+  }
+  return {
+    ok: true,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    location: {
+      place,
+      address,
+      lat: location.coords.latitude,
+      lng: location.coords.longitude,
+      type: locationType
+    }
+  };
+}
+async function ensurePermission() {
+  if (await hasPermission4()) return;
+  const granted = await requestPermission4();
+  if (!granted) {
+    throw new Error(
+      "Location permission was not granted. Enable it for this app in iOS Settings > Privacy > Location Services."
+    );
+  }
+}
+async function getPosition(opts = {}) {
+  await ensurePermission();
+  const fix = await ExpoLocation.getCurrentPositionAsync({
+    accuracy: opts.accuracy === "high" ? ExpoLocation.Accuracy.High : ExpoLocation.Accuracy.Balanced
+  });
+  return toPosition(fix);
+}
+function toPosition(fix) {
+  return {
+    latitude: fix.coords.latitude,
+    longitude: fix.coords.longitude,
+    altitude: fix.coords.altitude ?? void 0,
+    accuracy: nonNegative(fix.coords.accuracy),
+    timestamp: fix.timestamp ?? Date.now(),
+    speed: nonNegative(fix.coords.speed),
+    course: nonNegative(fix.coords.heading)
+  };
+}
+function nonNegative(v) {
+  return typeof v === "number" && v >= 0 ? v : void 0;
+}
+function watchPosition(cb) {
+  let subscription = null;
+  let cancelled = false;
+  (async () => {
+    try {
+      await ensurePermission();
+      if (cancelled) return;
+      subscription = await ExpoLocation.watchPositionAsync(
+        { accuracy: ExpoLocation.Accuracy.Balanced },
+        (fix) => cb(toPosition(fix))
+      );
+      if (cancelled) {
+        subscription?.remove();
+        subscription = null;
+      }
+    } catch (err) {
+      console.warn("[location] watchPosition failed:", err?.message || String(err));
+    }
+  })();
+  return () => {
+    cancelled = true;
+    subscription?.remove();
+    subscription = null;
+  };
+}
+function classifyLocation(geocoded) {
+  const name = (geocoded.name || "").toLowerCase();
+  const street = (geocoded.street || "").toLowerCase();
+  if (name.includes("home") || name.includes("residence")) return "home";
+  if (name.includes("office") || name.includes("workplace") || name.includes("tech park")) return "work";
+  if (name.includes("school") || name.includes("elementary") || name.includes("university")) return "school";
+  if (name.includes("gym") || name.includes("fitness")) return "fitness";
+  if (name.includes("hospital") || name.includes("clinic") || name.includes("dental")) return "medical";
+  return "other";
+}
+
+// src/device-bridge/collectors/battery.ts
+var ExpoBattery = __toESM(require("expo-battery"));
+async function collectBattery() {
+  const level = await ExpoBattery.getBatteryLevelAsync();
+  const state = await ExpoBattery.getBatteryStateAsync();
+  const lowPower = await ExpoBattery.isLowPowerModeEnabledAsync();
+  return {
+    ok: true,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    battery: {
+      level: Math.round(level * 100),
+      // expo-battery returns 0-1
+      state: mapBatteryState(state),
+      low_power_mode: lowPower
+    }
+  };
+}
+function subscribeToBattery(callback) {
+  let lastLevel = null;
+  const levelSub = ExpoBattery.addBatteryLevelListener(({ batteryLevel }) => {
+    const pct = Math.round(batteryLevel * 100);
+    if (lastLevel === null || Math.abs(pct - lastLevel) >= 5) {
+      lastLevel = pct;
+      callback();
+    }
+  });
+  const stateSub = ExpoBattery.addBatteryStateListener(() => {
+    callback();
+  });
+  return () => {
+    levelSub?.remove?.();
+    stateSub?.remove?.();
+  };
+}
+function mapBatteryState(state) {
+  switch (state) {
+    case ExpoBattery.BatteryState.CHARGING:
+      return "charging";
+    case ExpoBattery.BatteryState.FULL:
+      return "full";
+    case ExpoBattery.BatteryState.UNPLUGGED:
+    default:
+      return "unplugged";
+  }
+}
+
+// src/device-bridge/collectors/connectivity.ts
+var ExpoNetwork = __toESM(require("expo-network"));
+async function collectConnectivity() {
+  const networkState = await ExpoNetwork.getNetworkStateAsync();
+  let type = "none";
+  let wifiName;
+  let cellularType;
+  if (networkState.type === ExpoNetwork.NetworkStateType.WIFI) {
+    type = "wifi";
+    try {
+      wifiName = await getWifiName();
+    } catch {
+      wifiName = void 0;
+    }
+  } else if (networkState.type === ExpoNetwork.NetworkStateType.CELLULAR) {
+    type = "cellular";
+    cellularType = getCellularGeneration();
+  }
+  return {
+    ok: true,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    connectivity: {
+      type,
+      is_connected: networkState.isConnected ?? false,
+      ...wifiName && { wifi_name: wifiName },
+      ...cellularType && { cellular_type: cellularType }
+    }
+  };
+}
+async function getWifiName() {
+  return void 0;
+}
+function getCellularGeneration() {
+  return "LTE";
+}
+
+// src/device-bridge/collectors/notifications.ts
+var ExpoNotifications = __toESM(require("expo-notifications"));
+async function requestPermission5() {
+  const { status } = await ExpoNotifications.requestPermissionsAsync();
+  return status === "granted";
+}
+async function hasPermission5() {
+  const { status } = await ExpoNotifications.getPermissionsAsync();
+  return status === "granted";
+}
+async function collectNotifications() {
+  const presented = await ExpoNotifications.getPresentedNotificationsAsync();
+  const notifications = presented.map((n, i) => ({
+    id: n.request.identifier || `n${i}`,
+    app: n.request.content.data?.app || "A-Team",
+    title: n.request.content.title || "",
+    body: n.request.content.body || "",
+    timestamp: n.date ? new Date(n.date).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+    sender: n.request.content.data?.sender || null,
+    priority: mapPriority(n.request.content.data?.priority),
+    read: false
+    // Presented notifications are unread by definition
+  }));
+  const unread = notifications.filter((n) => !n.read).length;
+  return {
+    ok: true,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    total: notifications.length,
+    unread,
+    notifications
+  };
+}
+function mapPriority(p) {
+  if (p === "high" || p === "max") return "high";
+  if (p === "low" || p === "min") return "low";
+  return "medium";
+}
+
+// src/device-bridge/collectors/appEngagement.ts
+var import_react_native3 = require("react-native");
+var import_async_storage2 = __toESM(require("@react-native-async-storage/async-storage"));
+var KEY = "ateam.appEngagement.v1";
+var _tally = null;
+var _foregroundSince = null;
+function todayKey() {
+  const d = /* @__PURE__ */ new Date();
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+function fresh() {
+  return { date: todayKey(), sessions: 0, activeMs: 0 };
+}
+async function load() {
+  try {
+    const raw = await import_async_storage2.default.getItem(KEY);
+    if (raw) {
+      const parsed = JSON.parse(raw);
+      _tally = parsed?.date === todayKey() ? parsed : fresh();
+    } else {
+      _tally = fresh();
+    }
+  } catch {
+    _tally = fresh();
+  }
+}
+function persist() {
+  if (_tally) import_async_storage2.default.setItem(KEY, JSON.stringify(_tally)).catch(() => {
+  });
+}
+function rollIfNewDay() {
+  if (!_tally || _tally.date !== todayKey()) {
+    _tally = fresh();
+    persist();
+  }
+}
+function flushForeground() {
+  if (_foregroundSince == null || !_tally) return;
+  const now = Date.now();
+  const delta = now - _foregroundSince;
+  if (delta > 0) _tally.activeMs += delta;
+  _foregroundSince = now;
+}
+async function getToday() {
+  if (!_tally) await load();
+  rollIfNewDay();
+  flushForeground();
+  persist();
+  if (!_tally) return { app_sessions: null, app_active_min: null };
+  return {
+    app_sessions: _tally.sessions,
+    app_active_min: Math.round(_tally.activeMs / 6e4)
+  };
+}
+
+// src/device-bridge/collectors/mood.ts
+function emptySignals() {
+  return {
+    steps: null,
+    sleep_min: null,
+    screen_min: null,
+    night_screen_min: null,
+    places_count: null,
+    distance_km: null,
+    social_app_min: null,
+    video_app_min: null,
+    productivity_app_min: null,
+    messages_sent: null,
+    calls_count: null,
+    app_sessions: null,
+    app_active_min: null,
+    checkin_mood: null
+  };
+}
+async function collectToday3() {
+  const today = emptySignals();
+  try {
+    const h = await collectToday();
+    if (h) {
+      today.steps = typeof h.steps === "number" ? h.steps : null;
+      today.distance_km = typeof h.distance_km === "number" ? h.distance_km : null;
+    }
+  } catch {
+  }
+  try {
+    const x = await collectMoodExtras();
+    today.sleep_min = x.sleep_min;
+    today.resting_hr = x.resting_hr;
+    today.active_energy_kcal = x.active_energy_kcal;
+    today.exercise_min = x.exercise_min;
+  } catch {
+  }
+  try {
+    const e = await getToday();
+    today.app_sessions = e.app_sessions;
+    today.app_active_min = e.app_active_min;
+  } catch {
+  }
+  let timezone = "UTC";
+  try {
+    timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+  } catch {
+  }
+  return {
+    window: "today",
+    timezone,
+    collected_at: (/* @__PURE__ */ new Date()).toISOString(),
+    today
+  };
+}
+
+// src/device-bridge/collectors/camera.ts
+var import_expo_camera = require("expo-camera");
+async function hasPermission6() {
+  try {
+    return (await import_expo_camera.Camera.getCameraPermissionsAsync()).granted;
+  } catch {
+    return false;
+  }
+}
+async function requestPermission6() {
+  try {
+    return (await import_expo_camera.Camera.requestCameraPermissionsAsync()).granted;
+  } catch {
+    return false;
+  }
+}
+
+// src/device-bridge/capabilities.ts
+function calendarCapability() {
+  return {
+    id: "calendar",
+    name: "Calendar",
+    description: "Syncs your calendar events so your assistant knows your schedule.",
+    reason: "Needed for scheduling, meeting prep, commute alerts, and daily briefings.",
+    icon: "calendar",
+    requiresPermission: true,
+    permissionState: "not_requested",
+    requestPermission: requestPermission2,
+    checkPermission: hasPermission2,
+    collect: async () => {
+      const [today, upcoming] = await Promise.all([
+        collectToday2(),
+        collectUpcoming(7)
+      ]);
+      return { today, upcoming };
+    },
+    defaultInterval: 6e4
+    // 1 min
+  };
+}
+function contactsCapability() {
+  return {
+    id: "contacts",
+    name: "Contacts",
+    description: "Syncs your contacts so your assistant can find people and relationships.",
+    reason: "Needed for messaging, birthday reminders, and relationship insights.",
+    icon: "people",
+    requiresPermission: true,
+    permissionState: "not_requested",
+    requestPermission: requestPermission3,
+    checkPermission: hasPermission3,
+    collect: async () => {
+      const list = await collectAll();
+      if (list === null) return null;
+      return { contacts: list };
+    },
+    defaultInterval: 3e5
+    // 5 min
+  };
+}
+function locationCapability() {
+  return {
+    id: "location",
+    name: "Location",
+    description: "Syncs your location for weather, commute, and context-aware assistance.",
+    reason: "Needed for commute estimates, weather at your location, and situation detection.",
+    icon: "location",
+    requiresPermission: true,
+    permissionState: "not_requested",
+    requestPermission: requestPermission4,
+    checkPermission: hasPermission4,
+    collect: collectCurrent,
+    defaultInterval: 3e4
+    // 30 sec
+  };
+}
+function batteryCapability() {
+  return {
+    id: "battery",
+    name: "Battery",
+    description: "Syncs battery level and charging status.",
+    reason: "Helps your assistant adjust behavior when battery is low.",
+    icon: "battery",
+    requiresPermission: false,
+    permissionState: "not_needed",
+    requestPermission: async () => true,
+    checkPermission: async () => true,
+    collect: collectBattery,
+    defaultInterval: 6e4,
+    // 1 min
+    subscribe: subscribeToBattery
+  };
+}
+function connectivityCapability() {
+  return {
+    id: "connectivity",
+    name: "Connectivity",
+    description: "Syncs WiFi/cellular status.",
+    reason: "Helps your assistant know if you have internet access.",
+    icon: "wifi",
+    requiresPermission: false,
+    permissionState: "not_needed",
+    requestPermission: async () => true,
+    checkPermission: async () => true,
+    collect: collectConnectivity,
+    defaultInterval: 3e4
+    // 30 sec
+  };
+}
+function healthCapability() {
+  return {
+    id: "health",
+    name: "Health",
+    description: "Reads daily steps, floors, calories, and distance from Apple Health.",
+    reason: "Powers the personal health coach and pairs activity data with nutrition tracking.",
+    icon: "heart",
+    requiresPermission: true,
+    permissionState: "not_requested",
+    requestPermission,
+    checkPermission: hasPermission,
+    collect: async () => {
+      const days = await collectHistory(30);
+      const today = days[0] || await collectToday();
+      return { today, days };
+    },
+    defaultInterval: 3e5
+    // 5 min
+  };
+}
+function moodCapability() {
+  return {
+    id: "mood",
+    name: "Mood",
+    description: "Sends a daily behavioral-signal summary (activity, routine) to infer mood \u2014 not a medical diagnosis.",
+    reason: "Lets ada gently notice changes in energy, stress, and routine and check in.",
+    icon: "heart",
+    // No OS permission of its own — it derives from collectors that gate
+    // themselves (e.g. health). Treated as not_needed so the bridge syncs it
+    // whenever the user has the Mood toggle on.
+    requiresPermission: false,
+    permissionState: "not_needed",
+    requestPermission: async () => true,
+    checkPermission: async () => true,
+    collect: async () => {
+      return collectToday3();
+    },
+    defaultInterval: 36e5
+    // hourly — it's a daily summary, no need to spam
+  };
+}
+function cameraCapability() {
+  return {
+    id: "camera",
+    name: "Camera",
+    description: "Lets ada see through your camera to guide you \u2014 reading text and describing what's in front of you. Frames are analysed on the phone; nothing is stored or uploaded.",
+    reason: "Powers visual guidance (Ada Guide): a live view with on-device text and scene understanding.",
+    icon: "camera",
+    requiresPermission: true,
+    permissionState: "not_requested",
+    requestPermission: requestPermission6,
+    checkPermission: hasPermission6,
+    // LIVE, not synced: the camera is used in the moment (deviceState.visual / a
+    // widget's preview) and never collected to the relay. So collect never
+    // pushes — this capability's value is the USER GRANT + OS permission, exposed
+    // to the backend like every other, not a data payload. `null` = nothing to
+    // push, which the bridge skips (same contract contacts uses when unchanged).
+    collect: async () => null,
+    defaultInterval: 36e5
+    // never really collects; keep the poll rare
+  };
+}
+function notificationsCapability() {
+  return {
+    id: "notifications",
+    name: "Notifications",
+    description: "Syncs your notifications for triage and smart grouping.",
+    reason: "Needed for notification triage, priority filtering, and Do Not Disturb.",
+    icon: "notifications",
+    requiresPermission: true,
+    permissionState: "not_requested",
+    requestPermission: requestPermission5,
+    checkPermission: hasPermission5,
+    collect: collectNotifications,
+    defaultInterval: 15e3
+    // 15 sec
+  };
+}
+function allBuiltIn() {
+  return [
+    calendarCapability(),
+    contactsCapability(),
+    locationCapability(),
+    batteryCapability(),
+    connectivityCapability(),
+    notificationsCapability(),
+    healthCapability(),
+    moodCapability(),
+    cameraCapability()
+  ];
+}
+
+// src/device-bridge/background.ts
+var BACKGROUND_TASK_NAME = "DEVICE_BRIDGE_BACKGROUND_SYNC";
+var CAPABILITY_FACTORIES = {
+  calendar: calendarCapability,
+  contacts: contactsCapability,
+  location: locationCapability,
+  battery: batteryCapability,
+  connectivity: connectivityCapability,
+  notifications: notificationsCapability,
+  health: healthCapability
+};
+async function registerBackgroundSync(config) {
+  TaskManager.defineTask(BACKGROUND_TASK_NAME, async () => {
+    try {
+      const hasNew = await syncDomains(config, ["location", "battery", "calendar"]);
+      return hasNew ? BackgroundFetch.BackgroundFetchResult.NewData : BackgroundFetch.BackgroundFetchResult.NoData;
+    } catch (error) {
+      console.error("[DeviceBridge] Background sync failed:", error);
+      return BackgroundFetch.BackgroundFetchResult.Failed;
+    }
+  });
+  await BackgroundFetch.registerTaskAsync(BACKGROUND_TASK_NAME, {
+    minimumInterval: 300,
+    // 5 minutes (iOS will clamp to ~15 min)
+    stopOnTerminate: false,
+    startOnBoot: true
+  });
+}
+async function unregisterBackgroundSync() {
+  const isRegistered = await TaskManager.isTaskRegisteredAsync(
+    BACKGROUND_TASK_NAME
+  );
+  if (isRegistered) {
+    await BackgroundFetch.unregisterTaskAsync(BACKGROUND_TASK_NAME);
+  }
+}
+async function syncDomains(config, domains) {
+  const relay = new RelayClient({
+    relayUrl: config.relayUrl,
+    deviceId: config.deviceId,
+    tenant: config.tenant,
+    actorId: config.actorId,
+    apiKey: config.apiKey,
+    timeout: 15e3
+    // longer than foreground — background tasks are budget-limited but not latency-sensitive
+  });
+  const results = await Promise.allSettled(
+    domains.map((d) => collectAndPush(relay, d))
+  );
+  return results.some((r) => r.status === "fulfilled" && r.value);
+}
+async function collectAndPush(relay, domain) {
+  const factory = CAPABILITY_FACTORIES[domain];
+  if (!factory) {
+    console.warn(`[DeviceBridge] Unknown sync domain: ${domain}`);
+    return false;
+  }
+  const cap = factory();
+  if (cap.requiresPermission) {
+    const granted = await cap.checkPermission();
+    if (!granted) return false;
+  }
+  const data = await cap.collect();
+  const result = await relay.pushDomain(domain, data);
+  return result.ok;
+}
+
+// src/device-bridge/biometrics.ts
+var biometrics_exports = {};
+__export(biometrics_exports, {
+  authenticate: () => authenticate,
+  capabilities: () => capabilities
+});
+var LocalAuthentication = __toESM(require("expo-local-authentication"));
+async function capabilities() {
+  const [hasHardware, isEnrolled, types] = await Promise.all([
+    LocalAuthentication.hasHardwareAsync(),
+    LocalAuthentication.isEnrolledAsync(),
+    LocalAuthentication.supportedAuthenticationTypesAsync()
+  ]);
+  const supportedTypes = types.map((t) => {
+    if (t === LocalAuthentication.AuthenticationType.FINGERPRINT) return "fingerprint";
+    if (t === LocalAuthentication.AuthenticationType.FACIAL_RECOGNITION) return "face";
+    if (t === LocalAuthentication.AuthenticationType.IRIS) return "iris";
+    return "none";
+  }).filter((t) => t !== "none");
+  return { hasHardware, isEnrolled, supportedTypes };
+}
+async function authenticate(opts) {
+  try {
+    const res = await LocalAuthentication.authenticateAsync({
+      promptMessage: opts.reason,
+      cancelLabel: opts.cancelLabel,
+      disableDeviceFallback: opts.fallbackToPasscode === false
+    });
+    if (res.success) return { success: true };
+    return { success: false, error: res.error || "unknown" };
+  } catch (e) {
+    return { success: false, error: String(e?.message || e) };
+  }
+}
+
+// src/device-bridge/sharing.ts
+var sharing_exports = {};
+__export(sharing_exports, {
+  isAvailable: () => isAvailable,
+  shareFile: () => shareFile
+});
+var Sharing = __toESM(require("expo-sharing"));
+async function shareFile(fileUri, opts = {}) {
+  try {
+    const available = await Sharing.isAvailableAsync();
+    if (!available) return { ok: false, error: "sharing_unavailable" };
+    await Sharing.shareAsync(fileUri, opts);
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: String(e?.message || e) };
+  }
+}
+async function isAvailable() {
+  return Sharing.isAvailableAsync();
+}
+
+// src/device-bridge/scanner.ts
+var scanner_exports = {};
+__export(scanner_exports, {
+  CameraView: () => import_expo_camera2.CameraView,
+  normalizeResult: () => normalizeResult,
+  requestPermissions: () => requestPermissions,
+  useCameraPermissions: () => import_expo_camera2.useCameraPermissions
+});
+var import_expo_camera2 = require("expo-camera");
+async function requestPermissions() {
+  const { Camera: Camera2 } = await import("expo-camera");
+  const { status } = await Camera2.requestCameraPermissionsAsync();
+  return { granted: status === "granted", status };
+}
+function normalizeResult(r) {
+  return { type: r.type, data: r.data };
+}
+
+// src/device-bridge/index.ts
+var DeviceBridge = class {
+  constructor(config) {
+    // Capability registry
+    this.caps = /* @__PURE__ */ new Map();
+    this.syncTimers = /* @__PURE__ */ new Map();
+    this.subscriptions = /* @__PURE__ */ new Map();
+    this.domainStatus = /* @__PURE__ */ new Map();
+    this.running = false;
+    this.config = config;
+    this.relay = new RelayClient({
+      relayUrl: config.relayUrl,
+      deviceId: config.deviceId,
+      tenant: config.tenant,
+      actorId: config.actorId,
+      apiKey: config.apiKey
+    });
+    this.queuePoller = new QueuePoller({
+      relayClient: this.relay,
+      pollInterval: 5e3,
+      onActionExecuted: () => this.notifyStatusChange(),
+      onError: (error) => this.config.onError?.({
+        domain: "actions",
+        message: error.message,
+        code: "ACTION_ERROR",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    });
+  }
+  // ─── Capability Registration ───
+  /**
+   * Register a capability. Does NOT request permission — just makes it known.
+   * Can be called before or after startSync().
+   */
+  register(cap) {
+    this.caps.set(cap.id, cap);
+    this.domainStatus.set(cap.id, {
+      domain: cap.id,
+      lastSync: null,
+      state: "idle"
+    });
+  }
+  /**
+   * Register multiple capabilities at once.
+   */
+  registerAll(caps) {
+    for (const cap of caps) {
+      this.register(cap);
+    }
+  }
+  /**
+   * Get a registered capability by ID.
+   * Use this to read name/description/reason for your permission UI.
+   */
+  getCapability(id) {
+    return this.caps.get(id);
+  }
+  /**
+   * Get all registered capabilities with their current status.
+   */
+  listCapabilities() {
+    return Array.from(this.caps.values()).map((cap) => ({
+      id: cap.id,
+      name: cap.name,
+      permission: cap.permissionState,
+      sync: this.domainStatus.get(cap.id) || {
+        domain: cap.id,
+        lastSync: null,
+        state: "idle"
+      }
+    }));
+  }
+  // ─── Permissions (host app controls the flow) ───
+  /**
+   * Request permission for ONE capability.
+   * Call after showing your own explanation screen.
+   * If bridge is already running and granted, syncing starts automatically.
+   */
+  async requestPermission(capId) {
+    const cap = this.caps.get(capId);
+    if (!cap) throw new Error(`Capability "${capId}" not registered`);
+    if (!cap.requiresPermission) {
+      cap.permissionState = "not_needed";
+      return true;
+    }
+    const granted = await cap.requestPermission();
+    cap.permissionState = granted ? "granted" : "denied";
+    if (granted && this.running) {
+      this.startCapabilitySync(cap);
+    }
+    this.notifyStatusChange();
+    return granted;
+  }
+  /**
+   * Check permission WITHOUT prompting.
+   */
+  async checkPermission(capId) {
+    const cap = this.caps.get(capId);
+    if (!cap) throw new Error(`Capability "${capId}" not registered`);
+    if (!cap.requiresPermission) return "not_needed";
+    const granted = await cap.checkPermission();
+    cap.permissionState = granted ? "granted" : cap.permissionState;
+    return cap.permissionState;
+  }
+  /**
+   * Request ALL permissions sequentially (one at a time, not bombarded).
+   */
+  async requestAllPermissions() {
+    const results = /* @__PURE__ */ new Map();
+    for (const [id, cap] of this.caps) {
+      if (!cap.requiresPermission) {
+        cap.permissionState = "not_needed";
+        results.set(id, true);
+        continue;
+      }
+      const granted = await cap.requestPermission();
+      cap.permissionState = granted ? "granted" : "denied";
+      results.set(id, granted);
+    }
+    this.notifyStatusChange();
+    return results;
+  }
+  /**
+   * Get capabilities that still need permission.
+   * Use this to drive a "next permission" onboarding flow.
+   */
+  getPendingPermissions() {
+    return Array.from(this.caps.values()).filter(
+      (cap) => cap.requiresPermission && cap.permissionState === "not_requested"
+    );
+  }
+  // ─── Sync Control ───
+  /**
+   * Start syncing all permitted capabilities + action queue poller.
+   */
+  async startSync() {
+    if (this.running) return;
+    this.running = true;
+    for (const [, cap] of this.caps) {
+      const permitted = !cap.requiresPermission || cap.permissionState === "granted" || cap.permissionState === "not_needed";
+      if (permitted) {
+        this.startCapabilitySync(cap);
+      } else {
+        this.updateDomainStatus(cap.id, "error", "Permission not granted");
+      }
+    }
+    this.queuePoller.start();
+    if (this.config.tenant && this.config.apiKey) {
+      registerBackgroundSync({
+        relayUrl: this.config.relayUrl,
+        deviceId: this.config.deviceId,
+        tenant: this.config.tenant,
+        actorId: this.config.actorId,
+        apiKey: this.config.apiKey
+      }).catch((e) => console.warn("[adas/bridge] registerBackgroundSync failed:", e?.message || e));
+    }
+    this.notifyStatusChange();
+  }
+  /**
+   * Stop all syncing.
+   */
+  stopSync() {
+    this.running = false;
+    for (const [id, timer] of this.syncTimers) {
+      clearInterval(timer);
+      this.updateDomainStatus(id, "stopped");
+    }
+    this.syncTimers.clear();
+    for (const unsub of this.subscriptions.values()) {
+      try {
+        unsub();
+      } catch {
+      }
+    }
+    this.subscriptions.clear();
+    this.queuePoller.stop();
+    unregisterBackgroundSync().catch((e) => console.warn("[adas/bridge] unregisterBackgroundSync failed:", e?.message || e));
+    this.notifyStatusChange();
+  }
+  /**
+   * Force immediate sync of all permitted capabilities.
+   */
+  async syncNow() {
+    const promises = Array.from(this.caps.values()).filter((c) => c.permissionState === "granted" || c.permissionState === "not_needed").map((c) => this.syncCapability(c));
+    await Promise.allSettled(promises);
+  }
+  /**
+   * Force immediate sync of a single capability by id. Used by the host to
+   * refresh fast-moving sources (battery) on app-foreground so the relay
+   * gets a fresh reading the moment the user opens the app.
+   */
+  async syncCapabilityNow(capId) {
+    const cap = this.caps.get(capId);
+    if (!cap) return;
+    const permitted = !cap.requiresPermission || cap.permissionState === "granted" || cap.permissionState === "not_needed";
+    if (!permitted) return;
+    await this.syncCapability(cap);
+  }
+  /**
+   * Get current bridge status.
+   */
+  getStatus() {
+    return {
+      running: this.running,
+      capabilities: this.listCapabilities(),
+      lastFullSync: this.getLastFullSync(),
+      pendingActions: this.relay.getOfflineQueueSize()
+    };
+  }
+  /**
+   * Check if the relay is reachable.
+   */
+  async checkConnectivity() {
+    return this.relay.ping();
+  }
+  // ─── Internal ───
+  startCapabilitySync(cap) {
+    if (this.syncTimers.has(cap.id)) return;
+    const interval = this.config.syncIntervals?.[cap.id] ?? cap.defaultInterval;
+    this.syncCapability(cap);
+    const timer = setInterval(() => this.syncCapability(cap), interval);
+    this.syncTimers.set(cap.id, timer);
+    if (cap.subscribe && !this.subscriptions.has(cap.id)) {
+      try {
+        const unsub = cap.subscribe(() => {
+          if (this.running) this.syncCapability(cap);
+        });
+        this.subscriptions.set(cap.id, unsub);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        this.config.onError?.({
+          domain: cap.id,
+          message: `subscribe failed: ${message}`,
+          code: "SUBSCRIBE_ERROR",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    }
+  }
+  async syncCapability(cap) {
+    if (!this.running) return;
+    this.updateDomainStatus(cap.id, "syncing");
+    try {
+      const data = await cap.collect();
+      if (data === null) {
+        this.updateDomainStatus(cap.id, "idle");
+        return;
+      }
+      const result = await this.relay.pushDomain(cap.id, data);
+      if (result.ok) {
+        this.updateDomainStatus(cap.id, "idle");
+      } else {
+        this.updateDomainStatus(cap.id, "error", result.error);
+        this.config.onError?.({
+          domain: cap.id,
+          message: result.error || "Push failed",
+          code: "RELAY_ERROR",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.updateDomainStatus(cap.id, "error", message);
+      this.config.onError?.({
+        domain: cap.id,
+        message,
+        code: "COLLECTOR_ERROR",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
+  updateDomainStatus(id, state, error) {
+    const current = this.domainStatus.get(id);
+    this.domainStatus.set(id, {
+      domain: id,
+      lastSync: state === "idle" ? (/* @__PURE__ */ new Date()).toISOString() : current?.lastSync ?? null,
+      state,
+      error,
+      itemCount: current?.itemCount
+    });
+  }
+  getLastFullSync() {
+    const syncs = Array.from(this.domainStatus.values()).map((d) => d.lastSync).filter((s) => s !== null);
+    if (syncs.length === 0) return null;
+    return syncs.sort()[0];
+  }
+  notifyStatusChange() {
+    this.config.onStatusChange?.(this.getStatus());
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BACKGROUND_TASK_NAME,
+  DeviceBridge,
+  QueuePoller,
+  RelayClient,
+  biometrics,
+  capabilities,
+  location,
+  registerBackgroundSync,
+  scanner,
+  sharing,
+  syncDomains,
+  unregisterBackgroundSync
+});
+//# sourceMappingURL=index.js.map