@ateam-ai-mobile/expo 0.1.4 → 0.1.7

package/dist/chunk-VQJPSLHP.mjs

@@ -0,0 +1,1801 @@
+import {
+  getToday
+} from "./chunk-KOXF2FZM.mjs";
+import {
+  collectHistory,
+  collectMoodExtras,
+  collectToday,
+  hasPermission,
+  requestPermission
+} from "./chunk-XQSY6MHP.mjs";
+import {
+  __export
+} from "./chunk-WMJKH4XE.mjs";
+
+// 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
+import * as SMS from "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
+import * as ExpoCalendar from "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
+import * as Linking from "expo-linking";
+import { Platform } from "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 (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/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
+import * as TaskManager from "expo-task-manager";
+import * as BackgroundFetch from "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
+import * as ExpoCalendar2 from "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 startOfDay = 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, startOfDay, endOfDay);
+  const filtered = filterHolidays(events);
+  const mapped = filtered.map((e) => ({
+    id: e.id,
+    title: e.title || "Untitled",
+    date: startOfDay.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: startOfDay.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
+import * as ExpoContacts from "expo-contacts";
+import AsyncStorage from "@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 AsyncStorage.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 AsyncStorage.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
+});
+import * as ExpoLocation from "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
+import * as ExpoBattery from "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 connectivity_exports = {};
+__export(connectivity_exports, {
+  collectConnectivity: () => collectConnectivity
+});
+import * as ExpoNetwork from "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
+import * as ExpoNotifications from "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/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
+import { Camera } from "expo-camera";
+async function hasPermission6() {
+  try {
+    return (await Camera.getCameraPermissionsAsync()).granted;
+  } catch {
+    return false;
+  }
+}
+async function requestPermission6() {
+  try {
+    return (await 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
+});
+import * as LocalAuthentication from "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
+});
+import * as Sharing from "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: () => CameraView,
+  normalizeResult: () => normalizeResult,
+  requestPermissions: () => requestPermissions,
+  useCameraPermissions: () => useCameraPermissions
+});
+import { CameraView, useCameraPermissions } from "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());
+  }
+};
+
+export {
+  RelayClient,
+  QueuePoller,
+  location_exports,
+  connectivity_exports,
+  capabilities_exports,
+  BACKGROUND_TASK_NAME,
+  registerBackgroundSync,
+  unregisterBackgroundSync,
+  syncDomains,
+  biometrics_exports,
+  sharing_exports,
+  scanner_exports,
+  DeviceBridge
+};
+//# sourceMappingURL=chunk-VQJPSLHP.mjs.map