@ateam-ai-mobile/expo 0.1.19 → 0.1.21

package/dist/chunk-BAZFMTCC.mjs

@@ -0,0 +1,815 @@
+import {
+  RelayClient,
+  registerBackgroundSync,
+  unregisterBackgroundSync
+} from "./chunk-C62NQA4F.mjs";
+import {
+  collectHistory,
+  collectToday
+} from "./chunk-XQSY6MHP.mjs";
+import {
+  __export
+} from "./chunk-WMJKH4XE.mjs";
+
+// 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/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 } = await import("expo-camera");
+  const { status } = await Camera.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 {
+  QueuePoller,
+  biometrics_exports,
+  sharing_exports,
+  scanner_exports,
+  DeviceBridge
+};
+//# sourceMappingURL=chunk-BAZFMTCC.mjs.map