@ateam-ai-mobile/expo 0.1.19 → 0.1.21

package/dist/{chunk-Z5AI2SXX.mjs → chunk-C62NQA4F.mjs}

@@ -1,6 +1,3 @@
-import {
-  getToday
-} from "./chunk-KOXF2FZM.mjs";
 import {
   collectHistory,
   collectMoodExtras,
@@ -8,6 +5,9 @@ import {
   hasPermission,
   requestPermission
 } from "./chunk-XQSY6MHP.mjs";
+import {
+  getToday
+} from "./chunk-KOXF2FZM.mjs";
 import {
   reverseGeocode
 } from "./chunk-7FWYEHN5.mjs";
@@ -189,438 +189,176 @@ var RelayClient = class {
   }
 };
 
-// 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()
-    };
-  }
+// src/device-bridge/collectors/location.ts
+var location_exports = {};
+__export(location_exports, {
+  collectCurrent: () => collectCurrent,
+  getPosition: () => getPosition,
+  hasPermission: () => hasPermission2,
+  requestPermission: () => requestPermission2,
+  watchPosition: () => watchPosition
+});
+import * as ExpoLocation from "expo-location";
+async function requestPermission2() {
+  const { status: fg } = await ExpoLocation.requestForegroundPermissionsAsync();
+  if (fg !== "granted") return false;
   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()
-    };
+    await ExpoLocation.requestBackgroundPermissionsAsync();
+  } catch {
   }
+  return fg === "granted";
 }
-
-// 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 hasPermission2() {
+  const { status } = await ExpoLocation.getForegroundPermissionsAsync();
+  return status === "granted";
 }
-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()
-    };
-  }
+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 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
+    const geocoded = await reverseGeocode({
+      latitude: location.coords.latitude,
+      longitude: location.coords.longitude
     });
-    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);
-      }
+    if (geocoded) {
+      place = geocoded.name || geocoded.street || place;
+      address = [
+        geocoded.streetNumber,
+        geocoded.street,
+        geocoded.city,
+        geocoded.region
+      ].filter(Boolean).join(", ") || address;
+      locationType = classifyLocation(geocoded);
     }
-    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()
-    };
+  } catch {
   }
+  return {
+    ok: true,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    location: {
+      place,
+      address,
+      lat: location.coords.latitude,
+      lng: location.coords.longitude,
+      type: locationType
+    }
+  };
 }
-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()
-    };
+async function ensurePermission() {
+  if (await hasPermission2()) return;
+  const granted = await requestPermission2();
+  if (!granted) {
+    throw new Error(
+      "Location permission was not granted. Enable it for this app in iOS Settings > Privacy > Location Services."
+    );
   }
 }
-function formatTime(date) {
-  return date.toLocaleTimeString("en-US", {
-    hour: "2-digit",
-    minute: "2-digit",
-    hour12: false
+async function getPosition(opts = {}) {
+  await ensurePermission();
+  const fix = await ExpoLocation.getCurrentPositionAsync({
+    accuracy: opts.accuracy === "high" ? ExpoLocation.Accuracy.High : ExpoLocation.Accuracy.Balanced
   });
+  return toPosition(fix);
 }
-
-// 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()
-    };
-  }
+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)
+  };
 }
-
-// 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()
-    };
-  }
+function nonNegative(v) {
+  return typeof v === "number" && v >= 0 ? v : void 0;
 }
-
-// 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()
-    };
-  }
+var WATCH_TIER = {
+  navigation: ExpoLocation.Accuracy.BestForNavigation,
+  high: ExpoLocation.Accuracy.High,
+  balanced: ExpoLocation.Accuracy.Balanced,
+  low: ExpoLocation.Accuracy.Low
+};
+function watchPosition(cb, opts) {
+  let subscription = null;
+  let cancelled = false;
+  (async () => {
+    try {
+      await ensurePermission();
+      if (cancelled) return;
+      subscription = await ExpoLocation.watchPositionAsync(
+        { accuracy: WATCH_TIER[opts?.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;
+  };
 }
-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()
-    };
-  }
+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/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;
+// 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 {
-      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))
-      );
+      wifiName = await getWifiName();
+    } catch {
+      wifiName = void 0;
     }
+  } else if (networkState.type === ExpoNetwork.NetworkStateType.CELLULAR) {
+    type = "cellular";
+    cellularType = getCellularGeneration();
   }
-  /**
-   * 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()
-      };
+  return {
+    ok: true,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    connectivity: {
+      type,
+      is_connected: networkState.isConnected ?? false,
+      ...wifiName && { wifi_name: wifiName },
+      ...cellularType && { cellular_type: cellularType }
     }
-  }
-};
-
-// src/device-bridge/background.ts
-import * as TaskManager from "expo-task-manager";
-import * as BackgroundFetch from "expo-background-fetch";
+  };
+}
+async function getWifiName() {
+  return void 0;
+}
+function getCellularGeneration() {
+  return "LTE";
+}
 
 // src/device-bridge/capabilities.ts
 var capabilities_exports = {};
@@ -638,29 +376,29 @@ __export(capabilities_exports, {
 });
 
 // src/device-bridge/collectors/calendar.ts
-import * as ExpoCalendar2 from "expo-calendar";
-async function requestPermission2() {
-  const { status } = await ExpoCalendar2.requestCalendarPermissionsAsync();
+import * as ExpoCalendar from "expo-calendar";
+async function requestPermission3() {
+  const { status } = await ExpoCalendar.requestCalendarPermissionsAsync();
   return status === "granted";
 }
-async function hasPermission2() {
-  const { status } = await ExpoCalendar2.getCalendarPermissionsAsync();
+async function hasPermission3() {
+  const { status } = await ExpoCalendar.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 calendars = await ExpoCalendar.getCalendarsAsync(ExpoCalendar.EntityTypes.EVENT);
   const userCalendarIds = getUserCalendarIds(calendars);
-  const events = await ExpoCalendar2.getEventsAsync(userCalendarIds, startOfDay, endOfDay);
+  const events = await ExpoCalendar.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)),
+    start: formatTime(new Date(e.startDate)),
+    end: formatTime(new Date(e.endDate)),
     location: e.location || "",
     attendees: (e.attendees || []).map((a) => a.name || a.email || "Unknown"),
     notes: e.notes || ""
@@ -678,9 +416,9 @@ 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 calendars = await ExpoCalendar.getCalendarsAsync(ExpoCalendar.EntityTypes.EVENT);
   const userCalendarIds = getUserCalendarIds(calendars);
-  const events = await ExpoCalendar2.getEventsAsync(userCalendarIds, tomorrow, endDate);
+  const events = await ExpoCalendar.getEventsAsync(userCalendarIds, tomorrow, endDate);
   const filtered = filterHolidays(events);
   const mapped = filtered.map((e) => {
     const startDt = new Date(e.startDate);
@@ -688,8 +426,8 @@ async function collectUpcoming(daysAhead = 3) {
       id: e.id,
       title: e.title || "Untitled",
       date: startDt.toISOString().slice(0, 10),
-      start: formatTime2(startDt),
-      end: formatTime2(new Date(e.endDate)),
+      start: formatTime(startDt),
+      end: formatTime(new Date(e.endDate)),
       location: e.location || "",
       attendees: (e.attendees || []).map((a) => a.name || a.email || "Unknown"),
       notes: e.notes || ""
@@ -732,7 +470,7 @@ function filterHolidays(events) {
     return true;
   });
 }
-function formatTime2(date) {
+function formatTime(date) {
   return date.toLocaleTimeString("en-US", {
     hour: "2-digit",
     minute: "2-digit",
@@ -744,11 +482,11 @@ function formatTime2(date) {
 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() {
+async function requestPermission4() {
   const { status } = await ExpoContacts.requestPermissionsAsync();
   return status === "granted";
 }
-async function hasPermission3() {
+async function hasPermission4() {
   const { status } = await ExpoContacts.getPermissionsAsync();
   return status === "granted";
 }
@@ -814,169 +552,38 @@ async function collectAll() {
   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 reverseGeocode({
-      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);
-    }
+  try {
+    await AsyncStorage.setItem(HASH_STORE_KEY, JSON.stringify(currentHashes));
   } catch {
   }
-  return {
-    ok: true,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    location: {
-      place,
-      address,
-      lat: location.coords.latitude,
-      lng: location.coords.longitude,
-      type: locationType
-    }
-  };
+  return contacts;
 }
-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."
-    );
+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");
 }
-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;
-}
-var WATCH_TIER = {
-  navigation: ExpoLocation.Accuracy.BestForNavigation,
-  high: ExpoLocation.Accuracy.High,
-  balanced: ExpoLocation.Accuracy.Balanced,
-  low: ExpoLocation.Accuracy.Low
-};
-function watchPosition(cb, opts) {
-  let subscription = null;
-  let cancelled = false;
-  (async () => {
-    try {
-      await ensurePermission();
-      if (cancelled) return;
-      subscription = await ExpoLocation.watchPositionAsync(
-        { accuracy: WATCH_TIER[opts?.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 hashContact(c) {
+  const parts = [
+    c.id,
+    (c.name || "").trim(),
+    c.phone || "\0",
+    (c.email || "\0").toLowerCase(),
+    c.birthday || "\0"
+  ];
+  return fnv1a(parts.join(""));
 }
-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";
+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/battery.ts
@@ -1025,46 +632,6 @@ function mapBatteryState(state) {
   }
 }
 
-// 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() {
@@ -1186,8 +753,8 @@ function calendarCapability() {
     icon: "calendar",
     requiresPermission: true,
     permissionState: "not_requested",
-    requestPermission: requestPermission2,
-    checkPermission: hasPermission2,
+    requestPermission: requestPermission3,
+    checkPermission: hasPermission3,
     collect: async () => {
       const [today, upcoming] = await Promise.all([
         collectToday2(),
@@ -1208,8 +775,8 @@ function contactsCapability() {
     icon: "people",
     requiresPermission: true,
     permissionState: "not_requested",
-    requestPermission: requestPermission3,
-    checkPermission: hasPermission3,
+    requestPermission: requestPermission4,
+    checkPermission: hasPermission4,
     collect: async () => {
       const list = await collectAll();
       if (list === null) return null;
@@ -1228,8 +795,8 @@ function locationCapability() {
     icon: "location",
     requiresPermission: true,
     permissionState: "not_requested",
-    requestPermission: requestPermission4,
-    checkPermission: hasPermission4,
+    requestPermission: requestPermission2,
+    checkPermission: hasPermission2,
     collect: collectCurrent,
     defaultInterval: 3e4
     // 30 sec
@@ -1361,6 +928,8 @@ function allBuiltIn() {
 }
 
 // src/device-bridge/background.ts
+import * as TaskManager from "expo-task-manager";
+import * as BackgroundFetch from "expo-background-fetch";
 var BACKGROUND_TASK_NAME = "DEVICE_BRIDGE_BACKGROUND_SYNC";
 var CAPABILITY_FACTORIES = {
   calendar: calendarCapability,
@@ -1427,384 +996,14 @@ async function collectAndPush(relay, domain) {
   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
+  syncDomains
 };
-//# sourceMappingURL=chunk-Z5AI2SXX.mjs.map
+//# sourceMappingURL=chunk-C62NQA4F.mjs.map