@ateam-ai-mobile/expo 0.1.5 → 0.1.8

package/dist/bootstrap.js

@@ -0,0 +1,2991 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/device-bridge/cookies.ts
+var cookies_exports = {};
+__export(cookies_exports, {
+  clearAll: () => clearAll,
+  get: () => get,
+  set: () => set
+});
+async function get(url, includeHttpOnly = true) {
+  const raw = await import_cookies.default.get(url, includeHttpOnly);
+  const out = [];
+  for (const [name, c] of Object.entries(raw || {})) {
+    if (!c || typeof c !== "object") continue;
+    const value = typeof c.value === "string" ? c.value : String(c.value ?? "");
+    const cookie = { name, value };
+    if (c.domain) cookie.domain = String(c.domain);
+    if (c.path) cookie.path = String(c.path);
+    if (c.expires) {
+      const t = Date.parse(c.expires);
+      if (!Number.isNaN(t)) cookie.expires = Math.floor(t / 1e3);
+    }
+    if (typeof c.httpOnly === "boolean") cookie.httpOnly = c.httpOnly;
+    if (typeof c.secure === "boolean") cookie.secure = c.secure;
+    if (c.sameSite === "Lax" || c.sameSite === "Strict" || c.sameSite === "None") {
+      cookie.sameSite = c.sameSite;
+    }
+    out.push(cookie);
+  }
+  return out;
+}
+async function clearAll() {
+  try {
+    await import_cookies.default.clearAll(true);
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: String(e?.message || e) };
+  }
+}
+async function set(url, cookie) {
+  try {
+    await import_cookies.default.set(url, {
+      name: cookie.name,
+      value: cookie.value,
+      domain: cookie.domain,
+      path: cookie.path || "/",
+      httpOnly: cookie.httpOnly,
+      secure: cookie.secure
+    }, true);
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: String(e?.message || e) };
+  }
+}
+var import_cookies;
+var init_cookies = __esm({
+  "src/device-bridge/cookies.ts"() {
+    "use strict";
+    import_cookies = __toESM(require("@react-native-cookies/cookies"));
+  }
+});
+
+// src/device-bridge/nfc.ts
+var nfc_exports = {};
+__export(nfc_exports, {
+  isEnabled: () => isEnabled,
+  isSupported: () => isSupported3,
+  readOnce: () => readOnce
+});
+async function ensureInit() {
+  if (_initialized) return true;
+  try {
+    const supported = await import_react_native_nfc_manager.default.isSupported();
+    if (!supported) return false;
+    await import_react_native_nfc_manager.default.start();
+    _initialized = true;
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+async function isSupported3() {
+  try {
+    return await import_react_native_nfc_manager.default.isSupported();
+  } catch {
+    return false;
+  }
+}
+async function isEnabled() {
+  try {
+    return await import_react_native_nfc_manager.default.isEnabled();
+  } catch {
+    return false;
+  }
+}
+async function readOnce(timeoutMs = 3e4) {
+  const ready = await ensureInit();
+  if (!ready) return { ok: false, error: "nfc_unsupported" };
+  try {
+    const tag = await Promise.race([
+      import_react_native_nfc_manager.default.requestTechnology(import_react_native_nfc_manager.NfcTech.Ndef).then(() => import_react_native_nfc_manager.default.getTag()),
+      new Promise((resolve) => setTimeout(() => resolve(null), timeoutMs))
+    ]);
+    if (!tag) {
+      try {
+        await import_react_native_nfc_manager.default.cancelTechnologyRequest();
+      } catch {
+      }
+      return { ok: false, error: "timeout" };
+    }
+    const records = [];
+    if (tag.ndefMessage) {
+      for (const r of tag.ndefMessage) {
+        try {
+          const type = String.fromCharCode(...r.type || []);
+          const payload = import_react_native_nfc_manager.Ndef.text.decodePayload(r.payload || []);
+          records.push({ type, payload: String(payload) });
+        } catch {
+        }
+      }
+    }
+    const tagId = tag.id ? Array.from(tag.id).map((b) => b.toString(16).padStart(2, "0")).join("") : void 0;
+    return { ok: true, tagId, records };
+  } catch (e) {
+    return { ok: false, error: String(e?.message || e) };
+  } finally {
+    try {
+      await import_react_native_nfc_manager.default.cancelTechnologyRequest();
+    } catch {
+    }
+  }
+}
+var import_react_native_nfc_manager, _initialized;
+var init_nfc = __esm({
+  "src/device-bridge/nfc.ts"() {
+    "use strict";
+    import_react_native_nfc_manager = __toESM(require("react-native-nfc-manager"));
+    _initialized = false;
+  }
+});
+
+// src/bootstrap.ts
+var bootstrap_exports = {};
+__export(bootstrap_exports, {
+  bootstrapExpoAdas: () => bootstrapExpoAdas
+});
+module.exports = __toCommonJS(bootstrap_exports);
+var import_core2 = require("@ateam-ai-mobile/core");
+var import_plugin_runtime3 = require("@ateam-ai-mobile/plugin-runtime");
+var import_ui2 = require("@ateam-ai-mobile/ui");
+
+// src/index.ts
+var ExpoWebBrowser = __toESM(require("expo-web-browser"));
+var ExpoLinking = __toESM(require("expo-linking"));
+var ExpoClipboard = __toESM(require("expo-clipboard"));
+var import_async_storage3 = __toESM(require("@react-native-async-storage/async-storage"));
+var import_core = require("@ateam-ai-mobile/core");
+var import_plugin_runtime2 = require("@ateam-ai-mobile/plugin-runtime");
+var import_ui = require("@ateam-ai-mobile/ui");
+
+// src/haptics.ts
+var Haptics = __toESM(require("expo-haptics"));
+var expoHaptics = {
+  impact(style) {
+    const map = {
+      light: Haptics.ImpactFeedbackStyle.Light,
+      medium: Haptics.ImpactFeedbackStyle.Medium,
+      heavy: Haptics.ImpactFeedbackStyle.Heavy
+    };
+    Haptics.impactAsync(map[style]).catch(() => {
+    });
+  },
+  notification(type) {
+    const map = {
+      success: Haptics.NotificationFeedbackType.Success,
+      warning: Haptics.NotificationFeedbackType.Warning,
+      error: Haptics.NotificationFeedbackType.Error
+    };
+    Haptics.notificationAsync(map[type]).catch(() => {
+    });
+  },
+  selection() {
+    Haptics.selectionAsync().catch(() => {
+    });
+  },
+  // Shorthand for notification('error') — the form plugins actually call.
+  error() {
+    Haptics.notificationAsync(Haptics.NotificationFeedbackType.Error).catch(() => {
+    });
+  }
+};
+
+// src/bundleStorage.ts
+var FileSystem = __toESM(require("expo-file-system/legacy"));
+var import_async_storage = __toESM(require("@react-native-async-storage/async-storage"));
+var CACHE_DIR = `${FileSystem.cacheDirectory}plugin-bundles/`;
+var DEFAULT_CACHE_INDEX_KEY = "adas-plugin-bundles-index-v1";
+var ExpoBundleStorage = class {
+  /** Pass `indexKey` when migrating from an app that already persisted a
+   *  bundle index under a different key — keeps the existing cache warm. */
+  constructor(opts) {
+    this.dirReady = false;
+    this.indexKey = opts?.indexKey || DEFAULT_CACHE_INDEX_KEY;
+  }
+  async ensureDir() {
+    if (this.dirReady) return;
+    try {
+      const info = await FileSystem.getInfoAsync(CACHE_DIR);
+      if (!info.exists) {
+        await FileSystem.makeDirectoryAsync(CACHE_DIR, { intermediates: true });
+      }
+    } catch (err) {
+      console.warn("[ExpoBundleStorage] cache dir error:", err);
+    }
+    this.dirReady = true;
+  }
+  async loadIndex() {
+    try {
+      const raw = await import_async_storage.default.getItem(this.indexKey);
+      return raw ? JSON.parse(raw) : {};
+    } catch {
+      return {};
+    }
+  }
+  async saveIndex(index) {
+    try {
+      await import_async_storage.default.setItem(this.indexKey, JSON.stringify(index));
+    } catch (err) {
+      console.warn("[ExpoBundleStorage] index save error:", err);
+    }
+  }
+  async readBundle(localPath) {
+    try {
+      const info = await FileSystem.getInfoAsync(localPath);
+      if (!info.exists) return null;
+      return await FileSystem.readAsStringAsync(localPath);
+    } catch {
+      return null;
+    }
+  }
+  async writeBundle(key, content) {
+    await this.ensureDir();
+    const localPath = `${CACHE_DIR}${key}`;
+    await FileSystem.writeAsStringAsync(localPath, content);
+    return localPath;
+  }
+  async deleteBundle(localPath) {
+    await FileSystem.deleteAsync(localPath, { idempotent: true }).catch(() => {
+    });
+  }
+  async clearAll() {
+    await FileSystem.deleteAsync(CACHE_DIR, { idempotent: true }).catch(() => {
+    });
+    await import_async_storage.default.removeItem(this.indexKey).catch(() => {
+    });
+    this.dirReady = false;
+  }
+};
+
+// src/attachmentCache.ts
+var FileSystem2 = __toESM(require("expo-file-system/legacy"));
+var import_async_storage2 = __toESM(require("@react-native-async-storage/async-storage"));
+var DEFAULT_INDEX_KEY = "adas-chat-attachment-index-v1";
+var DIR = `${FileSystem2.documentDirectory}chat-attachments/`;
+var MAX_JOBS = 100;
+var ExpoAttachmentCache = class {
+  /** Pass `indexKey` when migrating from an app that already persisted an
+   *  index under a different AsyncStorage key — otherwise existing users
+   *  lose every cached preview on upgrade. */
+  constructor(opts) {
+    this.index = {};
+    const indexKey = opts?.indexKey || DEFAULT_INDEX_KEY;
+    this.indexKey = indexKey;
+    this.loaded = (async () => {
+      try {
+        const info = await FileSystem2.getInfoAsync(DIR);
+        if (!info.exists) await FileSystem2.makeDirectoryAsync(DIR, { intermediates: true });
+        const raw = await import_async_storage2.default.getItem(indexKey);
+        if (raw) this.index = JSON.parse(raw);
+      } catch {
+      }
+    })();
+  }
+  async ready() {
+    await this.loaded;
+  }
+  async save(jobId, attachments) {
+    await this.loaded;
+    const entries = [];
+    for (let i = 0; i < attachments.length; i++) {
+      const att = attachments[i];
+      const ext = att.mimeType.startsWith("image/") ? att.mimeType.split("/")[1] || "jpg" : "bin";
+      const filePath = `${DIR}${jobId}_${i}.${ext}`;
+      try {
+        await FileSystem2.writeAsStringAsync(filePath, att.data, { encoding: FileSystem2.EncodingType.Base64 });
+        entries.push({ mimeType: att.mimeType, name: att.name, filePath });
+      } catch (err) {
+        console.warn("[ExpoAttachmentCache] write failed:", err);
+      }
+    }
+    if (entries.length === 0) return;
+    this.index[jobId] = entries;
+    const keys = Object.keys(this.index);
+    if (keys.length > MAX_JOBS) {
+      for (const k of keys.slice(0, keys.length - MAX_JOBS)) {
+        const old = this.index[k];
+        if (old) for (const o of old) FileSystem2.deleteAsync(o.filePath, { idempotent: true }).catch(() => {
+        });
+        delete this.index[k];
+      }
+    }
+    try {
+      await import_async_storage2.default.setItem(this.indexKey, JSON.stringify(this.index));
+    } catch {
+    }
+  }
+  get(jobId) {
+    const entries = this.index[jobId];
+    if (!entries || entries.length === 0) return void 0;
+    return entries.map((e) => ({
+      mimeType: e.mimeType,
+      name: e.name,
+      previewUri: e.filePath
+    }));
+  }
+};
+
+// src/device-state/domains/deviceContext.ts
+var ExpoBattery = __toESM(require("expo-battery"));
+
+// src/device-state/quality.ts
+var import_plugin_runtime = require("@ateam-ai-mobile/plugin-runtime");
+var FRESH_MS = 1e4;
+var AGING_MS = 6e4;
+function qualityFrom(observedAt, confidence) {
+  const ageMs = Date.now() - observedAt;
+  return {
+    freshness: {
+      state: ageMs < FRESH_MS ? "fresh" : ageMs < AGING_MS ? "aging" : "stale",
+      observedAt,
+      ageMs
+    },
+    ...confidence ? { confidence } : {}
+  };
+}
+function qualityUnknown() {
+  return { freshness: (0, import_plugin_runtime.neverObserved)() };
+}
+function unsupported(what) {
+  const err = new Error(
+    `${what} is not implemented in this build \u2014 the native engine behind it does not exist yet.`
+  );
+  err.code = "UNSUPPORTED";
+  return err;
+}
+
+// src/device-state/events.ts
+function stateEvent(domain, name, payload, timestamp = Date.now()) {
+  return payload === void 0 ? { domain, name, timestamp } : { domain, name, timestamp, payload };
+}
+function listenerSet() {
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    add(fn) {
+      listeners.add(fn);
+      return { unsubscribe: () => {
+        listeners.delete(fn);
+      } };
+    },
+    emit(event) {
+      for (const fn of listeners) {
+        try {
+          fn(event);
+        } catch {
+        }
+      }
+    }
+  };
+}
+
+// src/device-state/domains/deviceContext.ts
+function createDeviceContextDomain() {
+  return {
+    async getSnapshot() {
+      const observedAt = Date.now();
+      try {
+        const [level, state, lowPower] = await Promise.all([
+          ExpoBattery.getBatteryLevelAsync(),
+          ExpoBattery.getBatteryStateAsync(),
+          ExpoBattery.isLowPowerModeEnabledAsync()
+        ]);
+        return {
+          power: {
+            // expo-battery returns -1 when it cannot tell. That is not a level.
+            batteryLevel: typeof level === "number" && level >= 0 ? level : null,
+            charging: state === ExpoBattery.BatteryState.CHARGING || state === ExpoBattery.BatteryState.FULL,
+            lowPowerMode: lowPower
+          },
+          // No Expo API for either. iOS needs ProcessInfo.thermalState, Android
+          // PowerManager.getThermalStatus — a native module that does not exist.
+          thermal: { state: "unknown" },
+          resources: { memoryPressure: "unknown", storagePressure: "unknown" },
+          quality: qualityFrom(observedAt)
+        };
+      } catch {
+        return {
+          power: { batteryLevel: null, charging: null, lowPowerMode: null },
+          thermal: { state: "unknown" },
+          resources: { memoryPressure: "unknown", storagePressure: "unknown" },
+          quality: qualityUnknown()
+        };
+      }
+    },
+    // Real events, not a placeholder: expo-battery exposes native listeners,
+    // so a plugin that subscribes genuinely hears about a change rather than
+    // sitting on a subscription that can never fire. Nudges without a payload:
+    // no Device Context payload schema is decided, so the subscriber re-reads.
+    subscribe(listener) {
+      const subs = [
+        ExpoBattery.addBatteryLevelListener(() => listener(stateEvent("deviceContext", "batteryLevelChanged"))),
+        ExpoBattery.addBatteryStateListener(() => listener(stateEvent("deviceContext", "chargingChanged")))
+      ];
+      return { unsubscribe: () => subs.forEach((x) => x?.remove?.()) };
+    }
+  };
+}
+
+// src/device-state/domains/connectivity.ts
+function createConnectivityDomain(collectors) {
+  return {
+    async getSnapshot() {
+      const observedAt = Date.now();
+      try {
+        if (!collectors.connectivity) throw unsupported("connectivity collector");
+        const data = await collectors.connectivity.collectConnectivity();
+        const online = data?.is_connected === true;
+        const type = String(data?.type || "").toLowerCase();
+        return {
+          reachability: data?.is_connected == null ? "unknown" : online ? "online" : "offline",
+          transport: type === "wifi" ? "wifi" : type === "cellular" ? "cellular" : type === "ethernet" ? "ethernet" : online ? "other" : data?.is_connected === false ? "none" : "unknown",
+          // All four below need measurement nobody takes yet. `unknown` is the
+          // designed answer — "return unknown rather than stale precision".
+          qualityClass: "unknown",
+          stability: "unknown",
+          latencyMs: null,
+          bandwidthClass: "unknown",
+          metered: null,
+          constrained: null,
+          quality: qualityFrom(observedAt)
+        };
+      } catch {
+        return {
+          reachability: "unknown",
+          transport: "unknown",
+          qualityClass: "unknown",
+          stability: "unknown",
+          latencyMs: null,
+          bandwidthClass: "unknown",
+          metered: null,
+          constrained: null,
+          quality: qualityUnknown()
+        };
+      }
+    },
+    // Intent selects a native sampling strategy — latency probes, quality
+    // classification. Nothing here samples anything, so accepting an intent
+    // would be accepting an instruction we do not carry out.
+    async start() {
+      throw unsupported("connectivity.start");
+    },
+    async stop() {
+      throw unsupported("connectivity.stop");
+    },
+    // A subscription that can never fire is worse than none: the caller
+    // reasonably reads silence as "nothing changed".
+    subscribe() {
+      throw unsupported("connectivity.subscribe");
+    }
+  };
+}
+
+// src/device-state/domains/capability.ts
+function statusFrom(granted) {
+  return {
+    support: "unknown",
+    permission: granted === null ? "unknown" : granted ? "granted" : "denied",
+    availability: "unknown"
+  };
+}
+var UNKNOWN_STATUS = {
+  support: "unknown",
+  permission: "unknown",
+  availability: "unknown"
+};
+function createCapabilityDomain(collectors) {
+  return {
+    async getSnapshot() {
+      const observedAt = Date.now();
+      const locationGranted = collectors.location ? await collectors.location.hasPermission().catch(() => null) : null;
+      return {
+        // Only location has a real reader today. The rest are declared by the
+        // contract and answered honestly rather than omitted.
+        camera: UNKNOWN_STATUS,
+        microphone: UNKNOWN_STATUS,
+        location: {
+          ...statusFrom(locationGranted),
+          // iOS 14+ distinguishes precise from approximate; nothing reads it.
+          precision: "unknown",
+          backgroundPermission: "unknown"
+        },
+        motion: UNKNOWN_STATUS,
+        bluetooth: UNKNOWN_STATUS,
+        uwb: UNKNOWN_STATUS,
+        nfc: UNKNOWN_STATUS,
+        quality: qualityFrom(observedAt)
+      };
+    },
+    // No OS permission-change stream is wired. Same reasoning as connectivity:
+    // silence would be indistinguishable from stability.
+    subscribe() {
+      throw unsupported("capability.subscribe");
+    }
+  };
+}
+
+// src/device-state/domains/interaction.ts
+var import_react_native = require("react-native");
+function createInteractionDomain() {
+  const mapState = (s) => s === "active" ? "foreground" : s === "background" ? "background" : s === "inactive" ? "inactive" : "unknown";
+  return {
+    async getSnapshot() {
+      const observedAt = Date.now();
+      return {
+        lifecycle: {
+          appState: mapState(import_react_native.AppState.currentState),
+          screenOn: null,
+          userActive: null,
+          idleDurationMs: null
+        },
+        audio: {
+          captureActive: null,
+          playbackActive: null,
+          route: "unknown",
+          interruption: "unknown"
+        },
+        // The voice block is OMITTED rather than filled with nulls: the design
+        // says a platform that cannot report voice session state leaves the
+        // group out instead of guessing `false` for each field. The app's own
+        // voice store knows this, but it is not reachable from the SDK.
+        quality: qualityFrom(observedAt)
+      };
+    },
+    // Real: AppState genuinely emits on every foreground/background change,
+    // which is the one part of this domain that works.
+    subscribe(listener) {
+      const sub2 = import_react_native.AppState.addEventListener("change", (next) => {
+        listener(stateEvent("interaction", "appStateChanged", { appState: mapState(next) }));
+      });
+      return { unsubscribe: () => sub2.remove() };
+    }
+  };
+}
+
+// src/device-state/headingSource.ts
+var ExpoLocation = __toESM(require("expo-location"));
+
+// src/device-state/turnDetector.ts
+function signedDelta(a, b) {
+  return (b - a + 540) % 360 - 180;
+}
+var TurnDetector = class {
+  constructor(opts = {}) {
+    /** The heading currently treated as "straight ahead". */
+    this.refDeg = null;
+    this.stableSince = 0;
+    this.lastTurn = null;
+    this.minTurnDeg = opts.minTurnDeg ?? 35;
+    this.stableDeg = opts.stableDeg ?? 12;
+    this.stableMs = opts.stableMs ?? 2500;
+  }
+  /** Feed one compass reading. `null` degrees means the compass said nothing. */
+  push(deg, now) {
+    if (deg === null) return null;
+    if (this.refDeg === null) {
+      this.refDeg = deg;
+      this.stableSince = now;
+      return null;
+    }
+    const delta = signedDelta(this.refDeg, deg);
+    if (Math.abs(delta) >= this.minTurnDeg) {
+      this.lastTurn = { deg: Math.round(delta), timestamp: now };
+      this.refDeg = deg;
+      this.stableSince = now;
+      return this.lastTurn;
+    }
+    if (Math.abs(delta) > this.stableDeg) {
+      this.stableSince = now;
+      return null;
+    }
+    if (now - this.stableSince >= this.stableMs) {
+      this.refDeg = deg;
+      this.stableSince = now;
+    }
+    return null;
+  }
+  /**
+   * The most recent completed turn, or null if none this session.
+   *
+   * It does NOT expire on its own: the age is derivable from `timestamp`, and
+   * "recent enough to mention" is a product judgement this layer must not make
+   * on the caller's behalf.
+   */
+  last() {
+    return this.lastTurn;
+  }
+  reset() {
+    this.refDeg = null;
+    this.stableSince = 0;
+    this.lastTurn = null;
+  }
+};
+
+// src/device-state/headingSource.ts
+var latest = null;
+var sub = null;
+var opening = null;
+var owners = /* @__PURE__ */ new Set();
+var turns = new TurnDetector();
+var turnListeners = listenerSet();
+function startHeading(owner) {
+  owners.add(owner);
+  if (sub) return Promise.resolve();
+  opening ?? (opening = open().finally(() => {
+    opening = null;
+  }));
+  return opening;
+}
+async function open() {
+  try {
+    const s = await ExpoLocation.watchHeadingAsync((h) => {
+      if (!owners.size) return;
+      const raw = h.trueHeading >= 0 ? h.trueHeading : h.magHeading;
+      const deg = typeof raw === "number" && raw >= 0 ? raw : null;
+      const cal = typeof h.accuracy === "number" && h.accuracy >= 0 ? h.accuracy : null;
+      const now = Date.now();
+      latest = { headingDeg: deg, calibration: cal, timestamp: now };
+      const turn = turns.push(deg, now);
+      if (turn) turnListeners.emit(turn);
+    });
+    if (!owners.size) {
+      s.remove();
+      return;
+    }
+    sub = s;
+  } catch {
+    sub = null;
+  }
+}
+function stopHeading(owner) {
+  owners.delete(owner);
+  if (owners.size) return;
+  sub?.remove();
+  sub = null;
+  latest = null;
+  turns.reset();
+}
+function onTurn(fn) {
+  return turnListeners.add(fn);
+}
+function currentHeading() {
+  return latest ? { headingDeg: latest.headingDeg } : null;
+}
+function currentHeadingDetail() {
+  return latest;
+}
+function lastMeaningfulTurn() {
+  return turns.last();
+}
+
+// src/geo.ts
+function distanceOf(path) {
+  const R = 6371e3;
+  let total = 0;
+  for (let i = 1; i < path.length; i++) {
+    const a = path[i - 1], b = path[i];
+    const dLat = (b.latitude - a.latitude) * Math.PI / 180;
+    const dLon = (b.longitude - a.longitude) * Math.PI / 180;
+    const la1 = a.latitude * Math.PI / 180, la2 = b.latitude * Math.PI / 180;
+    const h = Math.sin(dLat / 2) ** 2 + Math.cos(la1) * Math.cos(la2) * Math.sin(dLon / 2) ** 2;
+    total += 2 * R * Math.asin(Math.sqrt(h));
+  }
+  return Math.round(total);
+}
+
+// src/device-state/spatialEvents.ts
+var STATIONARY_MPS = 0.4;
+function movementStateOf(speedMps) {
+  return speedMps === null ? "unknown" : speedMps < STATIONARY_MPS ? "stationary" : "moving";
+}
+function fixConfidence(accuracyM) {
+  return accuracyM === null ? "unknown" : accuracyM <= 10 ? "high" : accuracyM <= 50 ? "medium" : "low";
+}
+var SPATIAL_EVENT_PROFILES = {
+  navigation: { movingHoldMs: 3e3, stoppedHoldMs: 5e3, confidenceHoldMs: 3e3, minMoveM: 10 },
+  fitness: { movingHoldMs: 3e3, stoppedHoldMs: 5e3, confidenceHoldMs: 5e3, minMoveM: 10 },
+  preciseLocate: { movingHoldMs: 2e3, stoppedHoldMs: 3e3, confidenceHoldMs: 2e3, minMoveM: 3 },
+  geofence: { movingHoldMs: 1e4, stoppedHoldMs: 3e4, confidenceHoldMs: 1e4, minMoveM: 25 },
+  lowPowerTracking: { movingHoldMs: 1e4, stoppedHoldMs: 3e4, confidenceHoldMs: 1e4, minMoveM: 50 }
+};
+function moveThresholdM(anchor, fix) {
+  const a = anchor.accuracyM ?? 0, b = fix.accuracyM ?? 0;
+  return 2 * Math.sqrt(a * a + b * b);
+}
+function spatialEventProfile(intent) {
+  return SPATIAL_EVENT_PROFILES[intent] ?? SPATIAL_EVENT_PROFILES.navigation;
+}
+var RANK = { high: 3, medium: 2, low: 1 };
+var MIN_FIXES = 2;
+function extend(run, state, fixAt2, now) {
+  if (!run || run.state !== state) return { state, since: now, fixAt: fixAt2, fixes: fixAt2 === null ? 0 : 1 };
+  if (fixAt2 !== null && fixAt2 !== run.fixAt) {
+    run.fixAt = fixAt2;
+    run.fixes++;
+  }
+  return run;
+}
+var settled = (run, now, holdMs) => run.fixes >= MIN_FIXES && now - run.since >= holdMs;
+var fixAt = (s) => s.position?.timestamp ?? null;
+var SpatialEventDetector = class {
+  constructor(profile = SPATIAL_EVENT_PROFILES.navigation) {
+    /** The movement state last settled on. Only MEASURED states settle. */
+    this.movement = "unknown";
+    this.run = null;
+    /** The completed turn already on record — reported turns, and the one the
+     *  session opened onto. Only a turn with a new timestamp is news. */
+    this.lastTurnAt = null;
+    /** The GPS band last settled on; null until the session's first band. */
+    this.band = null;
+    this.bandRun = null;
+    /** The last position REPORTED — distance is measured from here, not from
+     *  the previous fix, so a slow walk still adds up to a change. */
+    this.anchor = null;
+    this.staleArmed = true;
+    this.profile = profile;
+  }
+  /**
+   * Forget everything — a new session, or replay seeking backwards. Emits
+   * nothing. `turnOnRecordAt` is the timestamp of the turn already completed
+   * when the session opens (a visual session shares the compass): history, not
+   * news. Seeded from the turn itself rather than compared against a clock, so
+   * it holds whichever clock the turn was stamped with — epoch live, the
+   * recording's epoch in replay, where `now` is virtual.
+   */
+  reset(profile, turnOnRecordAt = null) {
+    if (profile) this.profile = profile;
+    this.movement = "unknown";
+    this.run = null;
+    this.lastTurnAt = turnOnRecordAt;
+    this.band = null;
+    this.bandRun = null;
+    this.anchor = null;
+    this.staleArmed = true;
+  }
+  /**
+   * Feed the newest snapshot. Returns what changed since the last one, in this
+   * order: movement, turn, position, confidence, staleness. Fields are read
+   * defensively — replay hands over recorded snapshots verbatim, and a recording
+   * may lack a block the live engine always fills.
+   */
+  push(snapshot, now) {
+    const out = [];
+    const emit = (name, payload) => {
+      out.push(stateEvent("spatial", name, payload, now));
+    };
+    this.movementFrom(snapshot, now, emit);
+    this.turnFrom(snapshot, emit);
+    this.positionFrom(snapshot, emit);
+    this.confidenceFrom(snapshot, now, emit);
+    this.staleFrom(snapshot, emit);
+    return out;
+  }
+  movementFrom(s, now, emit) {
+    const state = s.movement?.state ?? "unknown";
+    this.run = extend(this.run, state, fixAt(s), now);
+    if (state === this.movement) return;
+    if (state === "moving" && settled(this.run, now, this.profile.movingHoldMs)) {
+      emit("movementStarted", {
+        previous: this.movement === "stationary" ? "stationary" : "unknown",
+        speedMps: s.movement?.speedMps ?? null,
+        bearingDeg: s.movement?.bearingDeg ?? null,
+        since: this.run.since
+      });
+      this.movement = "moving";
+    } else if (state === "stationary" && settled(this.run, now, this.profile.stoppedHoldMs)) {
+      if (this.movement === "moving") emit("movementStopped", { previous: "moving", since: this.run.since });
+      this.movement = "stationary";
+    }
+  }
+  turnFrom(s, emit) {
+    const at = s.changes?.timestamp ?? null;
+    const deg = s.changes?.lastMeaningfulTurnDeg ?? null;
+    if (at === null || deg === null || at === this.lastTurnAt) return;
+    this.lastTurnAt = at;
+    emit("lastMeaningfulTurnChanged", { lastMeaningfulTurnDeg: deg, timestamp: at });
+  }
+  positionFrom(s, emit) {
+    const p = s.position ?? null;
+    if (!p) return;
+    if (!this.anchor) {
+      emit("positionChanged", { position: { ...p }, previous: null, distanceM: null });
+      this.anchor = p;
+      return;
+    }
+    const d = distanceOf([this.anchor, p]);
+    if (d < Math.max(this.profile.minMoveM, moveThresholdM(this.anchor, p))) {
+      const aNew = p.accuracyM ?? null, aOld = this.anchor.accuracyM ?? null;
+      if (aNew != null && aOld != null && aNew * 2 < aOld) this.anchor = p;
+      return;
+    }
+    emit("positionChanged", { position: { ...p }, previous: { ...this.anchor }, distanceM: d });
+    this.anchor = p;
+  }
+  confidenceFrom(s, now, emit) {
+    const p = s.position ?? null;
+    if (!p) return;
+    const level = fixConfidence(p.accuracyM ?? null);
+    if (level === "unknown") return;
+    if (this.band === null) {
+      this.band = level;
+      return;
+    }
+    if (level === this.band) {
+      this.bandRun = null;
+      return;
+    }
+    this.bandRun = extend(this.bandRun, level, fixAt(s), now);
+    if (!settled(this.bandRun, now, this.profile.confidenceHoldMs)) return;
+    emit("positionConfidenceChanged", {
+      level,
+      previous: this.band,
+      accuracyM: p.accuracyM ?? null,
+      direction: RANK[level] < RANK[this.band] ? "dropped" : "recovered"
+    });
+    this.band = level;
+    this.bandRun = null;
+  }
+  staleFrom(s, emit) {
+    const f = s.quality?.freshness;
+    if (!f) return;
+    if (f.state === "fresh") {
+      this.staleArmed = true;
+      return;
+    }
+    if (f.state !== "stale" || !this.staleArmed) return;
+    emit("spatialStateStale", { observedAt: f.observedAt, ageMs: f.ageMs });
+    this.staleArmed = false;
+  }
+};
+
+// src/device-state/domains/spatial.ts
+var WATCH_ACCURACY = {
+  navigation: "navigation",
+  preciseLocate: "high",
+  fitness: "high",
+  geofence: "balanced",
+  lowPowerTracking: "low"
+};
+function createSpatialDomain(collectors, speedRef) {
+  const RECENT_PATH_MAX = 60;
+  let recentPath = [];
+  let latest2 = null;
+  let latestSpeed = null;
+  let latestCourse = null;
+  let stopWatch = null;
+  let session = null;
+  const detector = new SpatialEventDetector();
+  const listeners = listenerSet();
+  let ticker = null;
+  let turnSub = null;
+  const nonNegative2 = (v) => typeof v === "number" && v >= 0 ? v : null;
+  const derivedSpeed = () => {
+    if (recentPath.length < 2) return null;
+    const b = recentPath[recentPath.length - 1];
+    const a = recentPath[recentPath.length - 2];
+    const dtS = (b.timestamp - a.timestamp) / 1e3;
+    if (dtS <= 0 || dtS > 10) return null;
+    return distanceOf([a, b]) / dtS;
+  };
+  const derivedCourse = () => {
+    if (recentPath.length < 2) return null;
+    const b = recentPath[recentPath.length - 1];
+    const a = recentPath[recentPath.length - 2];
+    if (b.timestamp - a.timestamp > 1e4) return null;
+    if (distanceOf([a, b]) < 3) return null;
+    return bearingBetween(a, b);
+  };
+  const snapshotFrom = (point2, measuredSpeed, measuredCourse) => {
+    let speedMps = measuredSpeed;
+    let courseDeg = measuredCourse;
+    let derived = false;
+    if (speedMps === null) {
+      const d = derivedSpeed();
+      if (d !== null) {
+        speedMps = d;
+        derived = true;
+      }
+    }
+    if (courseDeg === null) {
+      const d = derivedCourse();
+      if (d !== null) {
+        courseDeg = d;
+        derived = true;
+      }
+    }
+    const heading = currentHeadingDetail();
+    const turn = lastMeaningfulTurn();
+    return {
+      position: point2,
+      movement: {
+        speedMps,
+        bearingDeg: courseDeg,
+        // Needs two points from the SAME session; without a stream there is
+        // nothing to measure against, and a distance of 0 would read as
+        // "the user has not moved".
+        distanceRecentM: recentPath.length >= 2 ? distanceOf(recentPath) : null,
+        state: movementStateOf(speedMps)
+      },
+      orientation: {
+        headingDeg: heading?.headingDeg ?? null,
+        // NOT the calibration rank. iOS reports 0–3 (none…high), which is not
+        // a number of degrees, and converting one to the other would be an
+        // invented error bar. The rank drives `confidence` below instead.
+        headingAccuracyDeg: null
+      },
+      changes: {
+        lastMeaningfulTurnDeg: turn ? turn.deg : null,
+        timestamp: turn ? turn.timestamp : null
+      },
+      recentPath: [...recentPath],
+      quality: qualityFrom(
+        point2.timestamp,
+        spatialConfidence(point2.accuracyM ?? null, heading?.calibration ?? null, derived)
+      )
+    };
+  };
+  const noFix = () => ({
+    position: null,
+    movement: { speedMps: null, bearingDeg: null, distanceRecentM: null, state: "unknown" },
+    orientation: { headingDeg: currentHeadingDetail()?.headingDeg ?? null },
+    recentPath: [],
+    quality: qualityUnknown()
+  });
+  const warmSnapshot = () => latest2 ? snapshotFrom(latest2, latestSpeed, latestCourse) : null;
+  const observe = () => {
+    const snapshot = warmSnapshot();
+    if (!snapshot) return;
+    for (const event of detector.push(snapshot, Date.now())) listeners.emit(event);
+  };
+  const startTicking = () => {
+    ticker = setInterval(observe, 1e3);
+  };
+  const stopTicking = () => {
+    if (ticker) clearInterval(ticker);
+    ticker = null;
+  };
+  return {
+    async getSnapshot() {
+      const warm = warmSnapshot();
+      if (warm) return warm;
+      if (session) return noFix();
+      let point2;
+      let speedMps;
+      let courseDeg;
+      try {
+        if (!collectors.location) throw unsupported("location collector");
+        const fix = await collectors.location.getPosition({ accuracy: "low" });
+        point2 = {
+          latitude: fix.latitude,
+          longitude: fix.longitude,
+          altitude: fix.altitude ?? null,
+          accuracyM: nonNegative2(fix.accuracy),
+          timestamp: fix.timestamp ?? Date.now()
+        };
+        speedMps = nonNegative2(fix.speed);
+        courseDeg = nonNegative2(fix.course);
+      } catch {
+        return noFix();
+      }
+      return snapshotFrom(point2, speedMps, courseDeg);
+    },
+    /**
+     * Open the warm window: position stream + compass + event feed.
+     *
+     * The intent selects how eager the EVENTS are (spatialEvents.ts profiles)
+     * and the GPS TIER the stream runs at (WATCH_ACCURACY): navigation pays the
+     * battery for BestForNavigation; low-power tracking does not.
+     *
+     * A second `start()` while one is open joins the running session and is
+     * told ITS intent, not handed back the one it asked for: answering with the
+     * caller's intent would claim a profile that is not in force.
+     */
+    async start(options) {
+      if (session) return { ...session };
+      if (!collectors.location) throw unsupported("location collector");
+      const startedAt = Date.now();
+      session = { id: `spatial_${startedAt}`, intent: options.intent, startedAt };
+      detector.reset(spatialEventProfile(options.intent), lastMeaningfulTurn()?.timestamp ?? null);
+      void startHeading("spatial");
+      turnSub = onTurn(observe);
+      stopWatch = collectors.location.watchPosition((pos) => {
+        const p = {
+          latitude: pos.latitude,
+          longitude: pos.longitude,
+          altitude: pos.altitude ?? null,
+          accuracyM: nonNegative2(pos.accuracy),
+          timestamp: pos.timestamp ?? Date.now()
+        };
+        latest2 = p;
+        latestSpeed = nonNegative2(pos.speed);
+        latestCourse = nonNegative2(pos.course);
+        speedRef.mps = latestSpeed;
+        speedRef.at = p.timestamp;
+        recentPath = [...recentPath, p].slice(-RECENT_PATH_MAX);
+        observe();
+      }, { accuracy: WATCH_ACCURACY[options.intent] ?? "balanced" });
+      startTicking();
+      return { ...session };
+    },
+    async stop() {
+      stopWatch?.();
+      stopWatch = null;
+      session = null;
+      stopTicking();
+      turnSub?.unsubscribe();
+      turnSub = null;
+      detector.reset();
+      recentPath = [];
+      latest2 = null;
+      latestSpeed = null;
+      latestCourse = null;
+      speedRef.mps = null;
+      speedRef.at = 0;
+      stopHeading("spatial");
+    },
+    /**
+     * The six spatial events (see `SpatialEvent`). Subscribing opens no sensor:
+     * events flow only while a session is open, and a subscription made before
+     * `start()` hears that session from its first fix.
+     */
+    subscribe(listener) {
+      return listeners.add(listener);
+    }
+  };
+}
+function spatialConfidence(accuracyM, calibration, derived) {
+  const rank = (v) => v === "high" ? 3 : v === "medium" ? 2 : v === "low" ? 1 : 0;
+  const fromFix = fixConfidence(accuracyM);
+  const fromCompass = calibration === null ? "unknown" : calibration >= 3 ? "high" : calibration >= 2 ? "medium" : "low";
+  const parts = [fromFix, fromCompass, ...derived ? ["low"] : []];
+  const known = parts.filter((p) => p !== "unknown");
+  if (!known.length) return { level: "unknown" };
+  const worst = known.reduce((a, b) => rank(a) <= rank(b) ? a : b);
+  return { level: worst };
+}
+function bearingBetween(a, b) {
+  const toRad = (d) => d * Math.PI / 180;
+  const la1 = toRad(a.latitude), la2 = toRad(b.latitude);
+  const dLon = toRad(b.longitude - a.longitude);
+  const y = Math.sin(dLon) * Math.cos(la2);
+  const x = Math.cos(la1) * Math.sin(la2) - Math.sin(la1) * Math.cos(la2) * Math.cos(dLon);
+  return (Math.atan2(y, x) * 180 / Math.PI + 360) % 360;
+}
+
+// src/device-state/visualEngine.ts
+var PROFILES = {
+  navigation: { intervalMs: 1e3, windowMs: 5e3 },
+  accessibility: { intervalMs: 1e3, windowMs: 5e3 },
+  stream: { intervalMs: 500, windowMs: 5e3 },
+  inspection: { intervalMs: 2e3, windowMs: 8e3 },
+  shopping: { intervalMs: 2e3, windowMs: 5e3 },
+  document: { intervalMs: 3e3, windowMs: 3e3 },
+  ocr: { intervalMs: 3e3, windowMs: 3e3 },
+  highQuality: { intervalMs: 5e3, windowMs: 5e3 }
+};
+var VisualEngine = class {
+  constructor() {
+    this.frames = [];
+    this.session = null;
+    this.listeners = /* @__PURE__ */ new Set();
+    /** Set by the host component while a camera is actually mounted and ready. */
+    this.cameraReady = false;
+    /** Optional: supplies heading/position stamped onto each frame. */
+    this.context = null;
+    // The native ring's actual retention (ms). The engine's effective window is
+    // min(intent window, retention) — set by whoever owns the clamp semantics; this
+    // just stores the input so that logic has one source of truth to read.
+    this._retentionMs = null;
+  }
+  /** Host DI. Without it frames carry no orientation, and say so with nulls. */
+  setContextProvider(p) {
+    this.context = p;
+  }
+  // ── session ──
+  startSession(intent) {
+    if (this.session) return this.session;
+    this.session = {
+      id: `visual_${Date.now()}`,
+      intent: PROFILES[intent] ? intent : "navigation",
+      startedAt: Date.now(),
+      suspended: false
+    };
+    this.notify();
+    return this.session;
+  }
+  stopSession() {
+    this.session = null;
+    this.frames = [];
+    this.cameraReady = false;
+    this.notify();
+  }
+  /**
+   * Background: suspend, do not end.
+   *
+   * iOS tears the camera down when the app leaves the foreground. The session
+   * is a STATE that survives that; what does not survive is the claim that the
+   * camera is live. While suspended the ring is kept but ages — a read gets
+   * old frames clearly marked old, rather than a fresh-looking lie.
+   */
+  suspend() {
+    if (!this.session || this.session.suspended) return;
+    this.session.suspended = true;
+    this.cameraReady = false;
+    this.notify();
+  }
+  resume() {
+    if (!this.session?.suspended) return;
+    this.session.suspended = false;
+    this.notify();
+  }
+  getSession() {
+    return this.session;
+  }
+  /** Is a camera mounted and ready right now? Only the host knows. */
+  setCameraReady(ready) {
+    this.cameraReady = ready;
+    this.notify();
+  }
+  isCameraReady() {
+    return this.cameraReady && !this.session?.suspended;
+  }
+  // ── the ring ──
+  profile() {
+    const intent = this.session?.intent || "navigation";
+    return PROFILES[intent];
+  }
+  /**
+   * Feed from the native vision session (VisionSession, iOS) — the FAST frame
+   * source that replaces the takePictureAsync loop. The frame is IN-MEMORY: the
+   * native ring holds the pixels keyed by `id`, and native.vision resolves that
+   * id inside the trusted layer. No `uri` crosses here; the quality is a REAL
+   * measurement (not `unknown`), and `expiresAt` is the ring's real eviction time.
+   * The public VisualFrameRef strip to id-only is owned by the device-state session.
+   */
+  pushFrameMeta(meta) {
+    let heading = null;
+    try {
+      heading = this.context?.heading() ?? null;
+    } catch {
+    }
+    this.frames.push({
+      // In-memory: no file. native.vision resolves the id inside the native ring.
+      handle: { id: meta.id, mimeType: "image/none", expiresAt: meta.expiresAt ?? null },
+      timestamp: meta.timestamp,
+      orientation: { headingDeg: heading?.headingDeg ?? null, pitchDeg: null, rollDeg: null },
+      quality: meta.quality ?? { blur: "unknown", exposure: "unknown", obstructed: null }
+    });
+    this.evict();
+    this.notify();
+  }
+  setRetentionMs(ms) {
+    this._retentionMs = ms && ms > 0 ? ms : null;
+  }
+  retentionMs() {
+    return this._retentionMs;
+  }
+  /**
+   * How far back the timeline ACTUALLY reaches: `min(intent window, native
+   * retention)`.
+   *
+   * The intent asks for a window; native decides what it can afford to keep.
+   * Full-res luma at ~24fps is tens of megabytes for a few seconds, so the ring
+   * is memory-bounded and shrinks under pressure — `retentionMs` is native
+   * publishing what it is really holding.
+   *
+   * EVERY FRAME IN THE TIMELINE CAN BE ANALYSED. That is the one sentence a
+   * plugin author has to hold, and this clamp is what makes it true. The
+   * alternative — listing frames past retention marked "not analysable" — was
+   * considered and rejected: a caller would have to check a flag before every
+   * use, and forgetting throws mid-guidance on a frame the model can see
+   * listed. Present-but-unusable is the same trap as an empty rowset reading
+   * as "no rows matched".
+   *
+   * If per-frame history beyond retention is ever needed, the shape is an
+   * AGGREGATE on the snapshot ("the view has been unusable for N ms"), never a
+   * per-entry flag.
+   */
+  effectiveWindowMs() {
+    const intent = this.profile().windowMs;
+    const retention = this._retentionMs;
+    return retention === null ? intent : Math.min(intent, retention);
+  }
+  /**
+   * Time-based, not count-based: the design specifies a rolling WINDOW.
+   *
+   * Evicts on the EFFECTIVE window, so a frame whose pixels native has already
+   * dropped leaves the timeline at the same moment. Without this, `frameById`
+   * would start returning null for frames still being listed.
+   */
+  evict() {
+    const cutoff = Date.now() - this.effectiveWindowMs();
+    this.frames = this.frames.filter((f) => f.timestamp >= cutoff);
+  }
+  timeline() {
+    this.evict();
+    return { windowMs: this.effectiveWindowMs(), frames: [...this.frames] };
+  }
+  latest() {
+    this.evict();
+    return this.frames.length ? this.frames[this.frames.length - 1] : null;
+  }
+  /**
+   * Resolve a frame handle id (from a VisualFrameRef) back to the live frame so
+   * the mechanical layer — native.vision — can read its on-device file. The
+   * whole contract of that layer is that it takes an id, never pixels; this is
+   * where an id becomes a `handle.uri` it can open. Returns null when the id is
+   * unknown OR its frame has aged out of the rolling window (the cache file may
+   * also be gone by then) — a real "I can't look at that frame" answer, which
+   * the caller must treat as distinct from "I looked and found nothing".
+   */
+  frameById(id) {
+    this.evict();
+    return this.frames.find((f) => f.handle.id === id) ?? null;
+  }
+  /**
+   * Record a MEASURED quality back onto a frame (native.vision.assessQuality).
+   * Frames are minted with `quality: unknown` because nothing looks at the
+   * pixels at capture time; this is how a real measurement replaces that so a
+   * later read of VisualFrameRef.quality reflects it. No-op if the frame has
+   * aged out — we never resurrect an evicted frame just to label it.
+   */
+  setFrameQuality(id, quality) {
+    const f = this.frames.find((fr) => fr.handle.id === id);
+    if (!f) return;
+    f.quality = quality;
+    this.notify();
+  }
+  // ── change notification ──
+  subscribe(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+  notify() {
+    for (const fn of this.listeners) {
+      try {
+        fn();
+      } catch {
+      }
+    }
+  }
+};
+var visualEngine = new VisualEngine();
+function frameQuality(frame) {
+  if (!frame) return { freshness: { state: "unknown", observedAt: null, ageMs: null } };
+  const ageMs = Date.now() - frame.timestamp;
+  return {
+    freshness: {
+      // Tighter than the other domains on purpose: a two-second-old frame of a
+      // moving scene is not "fresh" in any useful sense.
+      state: ageMs < 2e3 ? "fresh" : ageMs < 1e4 ? "aging" : "stale",
+      observedAt: frame.timestamp,
+      ageMs
+    },
+    confidence: { level: "unknown" }
+  };
+}
+
+// src/device-state/domains/visual.ts
+function cameraState() {
+  const session = visualEngine.getSession();
+  return {
+    // `available` = the app could use a camera at all. `active` = one is
+    // running RIGHT NOW. They differ exactly when it matters: a pocketed
+    // phone is available but not active, and answering `true` to both
+    // would let a guide speak about a scene nothing is watching.
+    available: !!session,
+    active: visualEngine.isCameraReady(),
+    facing: session ? "back" : "unknown"
+  };
+}
+function createVisualDomain() {
+  return {
+    async getSnapshot() {
+      const latest2 = visualEngine.latest();
+      const timeline = visualEngine.timeline();
+      return {
+        camera: cameraState(),
+        // null, not a stale frame dressed as current. A caller with no usable
+        // frame must see nothing rather than something old.
+        latest: latest2,
+        recentTimeline: timeline,
+        quality: frameQuality(latest2)
+      };
+    },
+    async start(options) {
+      const s = visualEngine.startSession(options?.intent || "navigation");
+      visualEngine.setContextProvider({ heading: currentHeading });
+      void startHeading("visual");
+      return { id: s.id, intent: s.intent, startedAt: s.startedAt };
+    },
+    async stop() {
+      visualEngine.stopSession();
+      visualEngine.setContextProvider(null);
+      stopHeading("visual");
+    },
+    /**
+     * A deliberate one-shot. Distinct from getSnapshot because it is an
+     * OPERATION: it waits for a frame rather than serving the newest one.
+     *
+     * Throws when it cannot, rather than returning an empty result — the
+     * design is explicit that capture is an operation and reads are state.
+     */
+    async capture() {
+      if (!visualEngine.getSession()) {
+        throw unsupported("visual.capture without an open session \u2014 call start({ intent }) first");
+      }
+      if (!visualEngine.isCameraReady()) {
+        const err2 = new Error(
+          "The camera is not running right now \u2014 the app may be in the background."
+        );
+        err2.code = "TEMPORARILY_UNAVAILABLE";
+        throw err2;
+      }
+      const before = visualEngine.latest()?.timestamp ?? 0;
+      const deadline = Date.now() + 4e3;
+      while (Date.now() < deadline) {
+        const f = visualEngine.latest();
+        if (f && f.timestamp > before) return { frame: f };
+        await new Promise((r) => setTimeout(r, 100));
+      }
+      const err = new Error("No frame arrived within 4s.");
+      err.code = "TIMEOUT";
+      throw err;
+    },
+    /**
+     * Fires when the CAMERA block changes — a session opening or closing, the
+     * camera coming up or going down. The engine notifies on every frame too,
+     * and forwarding that made this a raw frame stream, which the freeze's core
+     * rule 4 forbids. A frame arriving is what `getSnapshot()` is for.
+     */
+    subscribe(listener) {
+      let last = JSON.stringify(cameraState());
+      const off = visualEngine.subscribe(() => {
+        const camera = cameraState();
+        const key = JSON.stringify(camera);
+        if (key === last) return;
+        last = key;
+        listener(stateEvent("visual", "visualStateChanged", { camera }));
+      });
+      return { unsubscribe: off };
+    }
+  };
+}
+
+// src/device-state/activityEngine.ts
+var sensors = null;
+var sensorsMissing = false;
+function loadSensors() {
+  if (sensors || sensorsMissing) return sensors;
+  try {
+    sensors = require("expo-sensors");
+  } catch {
+    sensorsMissing = true;
+    sensors = null;
+  }
+  return sensors;
+}
+var ACCEL_INTERVAL_MS = 200;
+var MOTION_WINDOW_MS = 3e3;
+var STEP_WINDOW_MS = 2e4;
+var GRAVITY_ALPHA = 0.1;
+var ActivityEngine = class {
+  constructor() {
+    this.accelSub = null;
+    this.stepSub = null;
+    this.magnitudes = [];
+    this.gravity = null;
+    this.steps = [];
+    this.sessionId = null;
+    this.startedAt = 0;
+    /** When the CURRENT reading last changed — feeds `human.since`. */
+    this.pedometerAvailable = null;
+    // ── transitions ──
+    //
+    // Tracked on a timer inside the engine rather than computed when someone
+    // reads, because a transition is an EVENT: "you started walking" happens
+    // between two reads, and a domain that only classifies on demand reports the
+    // state and loses the moment it changed. `since` has the same problem.
+    this.current = "unknown";
+    this.since = null;
+    this.transitions = [];
+    this.ticker = null;
+  }
+  isRunning() {
+    return this.sessionId !== null;
+  }
+  session() {
+    return this.sessionId ? { id: this.sessionId, startedAt: this.startedAt } : null;
+  }
+  /**
+   * @param classify how to name the current activity — injected so the engine
+   * keeps no opinion of its own and the classifier stays pure and testable.
+   */
+  async start(classify) {
+    if (this.sessionId) return this.session();
+    this.sessionId = `activity_${Date.now()}`;
+    this.startedAt = Date.now();
+    const s = loadSensors();
+    if (!s) {
+      this.pedometerAvailable = false;
+      this.startTicking(classify);
+      return this.session();
+    }
+    const { Accelerometer, Pedometer } = s;
+    Accelerometer.setUpdateInterval(ACCEL_INTERVAL_MS);
+    this.accelSub = Accelerometer.addListener(({ x, y, z }) => {
+      const now = Date.now();
+      this.magnitudes.push({ m: Math.sqrt(x * x + y * y + z * z), t: now });
+      const cutoff = now - MOTION_WINDOW_MS;
+      if (this.magnitudes.length > 8 && this.magnitudes[0].t < cutoff) {
+        this.magnitudes = this.magnitudes.filter((s2) => s2.t >= cutoff);
+      }
+      this.gravity = this.gravity ? {
+        x: this.gravity.x + GRAVITY_ALPHA * (x - this.gravity.x),
+        y: this.gravity.y + GRAVITY_ALPHA * (y - this.gravity.y),
+        z: this.gravity.z + GRAVITY_ALPHA * (z - this.gravity.z)
+      } : { x, y, z };
+    });
+    try {
+      this.pedometerAvailable = await Pedometer.isAvailableAsync();
+    } catch {
+      this.pedometerAvailable = false;
+    }
+    if (this.pedometerAvailable) {
+      try {
+        this.stepSub = Pedometer.watchStepCount(({ steps }) => {
+          this.steps.push({ steps, t: Date.now() });
+          const cutoff = Date.now() - STEP_WINDOW_MS;
+          if (this.steps.length > 2 && this.steps[0].t < cutoff) {
+            this.steps = this.steps.filter((s2) => s2.t >= cutoff);
+          }
+        });
+      } catch {
+        this.stepSub = null;
+        this.pedometerAvailable = false;
+      }
+    }
+    this.startTicking(classify);
+    return this.session();
+  }
+  stop() {
+    this.accelSub?.remove();
+    this.stepSub?.remove();
+    this.accelSub = null;
+    this.stepSub = null;
+    this.sessionId = null;
+    this.stopTicking();
+    this.magnitudes = [];
+    this.steps = [];
+    this.gravity = null;
+  }
+  /** Variance of accelerometer magnitude over the motion window, in g². */
+  accelVariance() {
+    const cutoff = Date.now() - MOTION_WINDOW_MS;
+    const window = this.magnitudes.filter((s) => s.t >= cutoff);
+    if (window.length < 5) return null;
+    const mean = window.reduce((a, s) => a + s.m, 0) / window.length;
+    return window.reduce((a, s) => a + (s.m - mean) ** 2, 0) / window.length;
+  }
+  currentGravity() {
+    return this.gravity;
+  }
+  /**
+   * Steps per minute over the step window.
+   *
+   * Computed from the DIFFERENCE between the first and last cumulative counts,
+   * so it does not matter whether the platform counts from subscription start
+   * or from midnight.
+   *
+   * Returns null — not 0 — when the window is too short to divide by. Zero
+   * steps per minute is a real claim ("standing still") and must only be made
+   * once there is a window long enough to support it.
+   */
+  cadenceSpm() {
+    const cutoff = Date.now() - STEP_WINDOW_MS;
+    const window = this.steps.filter((s) => s.t >= cutoff);
+    if (window.length < 2) {
+      if (this.pedometerAvailable && Date.now() - this.startedAt > STEP_WINDOW_MS) return 0;
+      return null;
+    }
+    const first = window[0], last = window[window.length - 1];
+    const minutes = (last.t - first.t) / 6e4;
+    if (minutes <= 0) return null;
+    return (last.steps - first.steps) / minutes;
+  }
+  /** Whether a pedometer exists and is permitted. Null before `start()`. */
+  hasPedometer() {
+    return this.pedometerAvailable;
+  }
+  /** When the newest sample arrived — what freshness is actually about. */
+  observedAt() {
+    const ts = [
+      this.magnitudes[this.magnitudes.length - 1]?.t,
+      this.steps[this.steps.length - 1]?.t
+    ].filter((t) => typeof t === "number");
+    return ts.length ? Math.max(...ts) : null;
+  }
+  /** Feed the engine its own classification once a second. */
+  startTicking(classify) {
+    this.ticker = setInterval(() => {
+      const next = classify();
+      if (next === this.current) return;
+      this.current = next;
+      this.since = Date.now();
+      this.transitions = [...this.transitions, { name: next, timestamp: this.since }].slice(-10);
+    }, 1e3);
+  }
+  stopTicking() {
+    if (this.ticker) clearInterval(this.ticker);
+    this.ticker = null;
+    this.current = "unknown";
+    this.since = null;
+    this.transitions = [];
+  }
+  /** When the current activity began, or null if it has not been established. */
+  currentSince() {
+    return this.since;
+  }
+  /** Newest last, bounded. Empty is a real answer: nothing has changed yet. */
+  recentTransitions() {
+    return [...this.transitions];
+  }
+};
+var activityEngine = new ActivityEngine();
+
+// src/device-state/activityClassifier.ts
+var RUN_SPM = 140;
+var WALK_SPM = 20;
+var STILL_VAR = 2e-3;
+var ACTIVE_VAR = 0.02;
+var VEHICLE_MPS = 3;
+var AXIS_DOMINANT = 0.75;
+function classifyActivity(input) {
+  return { human: classifyHuman(input), pose: classifyPose(input) };
+}
+function classifyHuman({ cadenceSpm, accelVariance, speedMps }) {
+  if (cadenceSpm !== null && cadenceSpm >= RUN_SPM) {
+    return { state: "running", confidence: { level: "high" } };
+  }
+  if (cadenceSpm !== null && cadenceSpm >= WALK_SPM) {
+    return { state: "walking", confidence: { level: "high" } };
+  }
+  if (speedMps !== null && speedMps >= VEHICLE_MPS) {
+    return { state: "unknown", confidence: { level: "low" } };
+  }
+  if (accelVariance !== null && accelVariance < STILL_VAR && (cadenceSpm === null || cadenceSpm < WALK_SPM)) {
+    return { state: "stationary", confidence: { level: "medium" } };
+  }
+  return { state: "unknown", confidence: { level: "unknown" } };
+}
+function classifyPose({ gravity, accelVariance }) {
+  if (!gravity) {
+    return { placement: "unknown", orientation: "unknown", confidence: { level: "unknown" } };
+  }
+  const { x, y, z } = gravity;
+  const orientation = Math.abs(z) >= AXIS_DOMINANT ? "flat" : Math.abs(y) >= AXIS_DOMINANT ? "portrait" : Math.abs(x) >= AXIS_DOMINANT ? "landscape" : "unknown";
+  if (orientation === "flat" && accelVariance !== null && accelVariance < STILL_VAR) {
+    return { placement: "table", orientation, confidence: { level: "high" } };
+  }
+  if (orientation !== "flat" && accelVariance !== null && accelVariance >= ACTIVE_VAR) {
+    return { placement: "handheld", orientation, confidence: { level: "medium" } };
+  }
+  return { placement: "unknown", orientation, confidence: { level: "unknown" } };
+}
+
+// src/device-state/domains/activity.ts
+function createActivityDomain(speedRef) {
+  const SPEED_MAX_AGE_MS = 15e3;
+  const input = () => ({
+    cadenceSpm: activityEngine.cadenceSpm(),
+    accelVariance: activityEngine.accelVariance(),
+    gravity: activityEngine.currentGravity(),
+    speedMps: speedRef.at && Date.now() - speedRef.at < SPEED_MAX_AGE_MS ? speedRef.mps : null
+  });
+  return {
+    async getSnapshot() {
+      if (!activityEngine.isRunning()) {
+        return {
+          human: { state: "unknown", since: null, confidence: { level: "unknown" } },
+          devicePose: { placement: "unknown", orientation: "unknown", confidence: { level: "unknown" } },
+          recentTransitions: [],
+          quality: qualityUnknown()
+        };
+      }
+      const verdict = classifyActivity(input());
+      const observedAt = activityEngine.observedAt();
+      const transitions = activityEngine.recentTransitions();
+      return {
+        human: {
+          state: verdict.human.state,
+          since: activityEngine.currentSince(),
+          confidence: verdict.human.confidence
+        },
+        devicePose: {
+          placement: verdict.pose.placement,
+          orientation: verdict.pose.orientation,
+          confidence: verdict.pose.confidence
+        },
+        transition: {
+          current: verdict.human.state,
+          // A hint, and we have no basis for one. The freeze calls `likelyNext`
+          // advisory; advisory is not licence to invent it.
+          likelyNext: null
+        },
+        recentTransitions: transitions,
+        quality: observedAt === null ? qualityUnknown() : qualityFrom(observedAt, verdict.human.confidence)
+      };
+    },
+    /**
+     * Start sampling. The intent is recorded but does not yet change strategy —
+     * there is no native power-tuning layer for it to reach.
+     */
+    async start(options) {
+      const s = await activityEngine.start(() => classifyActivity(input()).human.state);
+      return { id: s.id, intent: options.intent, startedAt: s.startedAt };
+    },
+    async stop() {
+      activityEngine.stop();
+    },
+    // No activity event vocabulary is frozen — the design notes there is no
+    // "Initial Activity Events" list at all — so naming events here would put
+    // words in plugins that the freeze may contradict.
+    subscribe() {
+      throw unsupported("activity.subscribe");
+    }
+  };
+}
+
+// src/device-state/index.ts
+function createDeviceState(collectors = {}) {
+  const speedRef = { mps: null, at: 0 };
+  return {
+    deviceContext: createDeviceContextDomain(),
+    connectivity: createConnectivityDomain(collectors),
+    capability: createCapabilityDomain(collectors),
+    interaction: createInteractionDomain(),
+    spatial: createSpatialDomain(collectors, speedRef),
+    visual: createVisualDomain(),
+    activity: createActivityDomain(speedRef)
+  };
+}
+
+// src/camera/CameraTaskHost.tsx
+var import_react = require("react");
+var import_react_native2 = require("react-native");
+var import_expo_camera = require("expo-camera");
+
+// src/camera/cameraTasks.ts
+function cameraError(code, message) {
+  const err = new Error(message);
+  err.code = code;
+  return err;
+}
+var CameraTaskBroker = class {
+  constructor() {
+    this.task = null;
+    this.listeners = /* @__PURE__ */ new Set();
+    /** Set by the host while a camera is mounted and ready. */
+    this.hostMounted = false;
+  }
+  current() {
+    return this.task;
+  }
+  subscribe(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+  /**
+   * Declare that a `CameraTaskHost` exists.
+   *
+   * Without it nothing will ever settle the promise, so a request must fail
+   * IMMEDIATELY and say why. The alternative is a plugin awaiting forever,
+   * which is the worst failure of the set: no error, no timeout, no camera,
+   * and a conversation that simply stops.
+   */
+  setHostMounted(mounted) {
+    this.hostMounted = mounted;
+    if (!mounted) this.fail(cameraError("UNAVAILABLE", "The camera surface was dismissed before the task completed."));
+    this.notify();
+  }
+  isHostMounted() {
+    return this.hostMounted;
+  }
+  /** Enqueue and hand back the promise the plugin awaits. */
+  run(kind, opts) {
+    if (!this.hostMounted) {
+      return Promise.reject(cameraError(
+        "UNAVAILABLE",
+        "No camera surface is mounted in this app, so the camera cannot be shown. The host must render <CameraTaskHost /> once, near the app root."
+      ));
+    }
+    if (this.task) {
+      return Promise.reject(cameraError(
+        "BUSY",
+        `The camera is already in use (${this.task.kind}). Only one camera task can run at a time.`
+      ));
+    }
+    return new Promise((resolve, reject) => {
+      this.task = { kind, opts, resolve, reject };
+      this.notify();
+    });
+  }
+  /** Settle the running task successfully and clear it. */
+  complete(value) {
+    const t = this.task;
+    if (!t) return;
+    this.task = null;
+    this.notify();
+    t.resolve(value);
+  }
+  /** Settle the running task with a failure and clear it. */
+  fail(err) {
+    const t = this.task;
+    if (!t) return;
+    this.task = null;
+    this.notify();
+    t.reject(err);
+  }
+  /**
+   * The user backed out.
+   *
+   * A distinct code, because "the user chose not to" is not a malfunction and
+   * a guide should say something different about it than about a broken lens.
+   */
+  cancel() {
+    this.fail(cameraError("CANCELLED", "Cancelled \u2014 the camera was dismissed before anything was captured."));
+  }
+  notify() {
+    for (const fn of this.listeners) {
+      try {
+        fn();
+      } catch {
+      }
+    }
+  }
+};
+var cameraTasks = new CameraTaskBroker();
+
+// src/camera/CameraTaskHost.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var styles = import_react_native2.StyleSheet.create({
+  overlay: { ...import_react_native2.StyleSheet.absoluteFillObject, backgroundColor: "#000", zIndex: 9999 },
+  hud: { flex: 1, justifyContent: "space-between", paddingVertical: 64, alignItems: "center" },
+  hint: { color: "#fff", fontSize: 16, textAlign: "center", paddingHorizontal: 24 },
+  cancel: { paddingHorizontal: 28, paddingVertical: 14, borderRadius: 24, backgroundColor: "rgba(255,255,255,0.18)" },
+  cancelText: { color: "#fff", fontSize: 16, fontWeight: "600" }
+});
+
+// src/index.ts
+function setupExpoProviders(opts) {
+  (0, import_plugin_runtime2.setHapticsProvider)(expoHaptics);
+  if (opts?.deviceProvider) (0, import_plugin_runtime2.setPluginNativeProvider)(opts.deviceProvider);
+  (0, import_plugin_runtime2.setBundleStorage)(new ExpoBundleStorage({ indexKey: opts?.bundleIndexKey }));
+  (0, import_ui.setClipboardProvider)({
+    setString: (text2) => ExpoClipboard.setStringAsync(text2).then(() => {
+    })
+  });
+  (0, import_plugin_runtime2.registerBundleModules)({
+    "expo-web-browser": ExpoWebBrowser,
+    "expo-linking": ExpoLinking,
+    ...opts?.bundleModules || {}
+  });
+  (0, import_core.setAcsCacheStorage)({
+    getItem: (k) => import_async_storage3.default.getItem(k),
+    setItem: (k, v) => import_async_storage3.default.setItem(k, v)
+  });
+  return { attachmentCache: new ExpoAttachmentCache({ indexKey: opts?.attachmentIndexKey }) };
+}
+
+// src/device/createDeviceProvider.ts
+var Haptics2 = __toESM(require("expo-haptics"));
+var ExpoLocation4 = __toESM(require("expo-location"));
+var ImagePicker = __toESM(require("expo-image-picker"));
+var Notifications = __toESM(require("expo-notifications"));
+var DocumentPicker = __toESM(require("expo-document-picker"));
+var FS = __toESM(require("expo-file-system"));
+var SQLite = __toESM(require("expo-sqlite"));
+var import_async_storage6 = __toESM(require("@react-native-async-storage/async-storage"));
+
+// src/vision/index.ts
+var import_expo_modules_core = require("expo-modules-core");
+var import_expo = require("expo");
+var CameraPreview = (() => {
+  try {
+    return (0, import_expo.requireNativeView)("AdaVision");
+  } catch {
+    return null;
+  }
+})();
+var native = (0, import_expo_modules_core.requireOptionalNativeModule)("AdaVision");
+function isSupported() {
+  try {
+    return native?.isSupported() ?? false;
+  } catch {
+    return false;
+  }
+}
+function qualityById(id) {
+  return native?.qualityById?.(id) ?? null;
+}
+async function readText(id, languages) {
+  if (!native) throw new Error("ada-vision native module not present in this build");
+  return native.readText(id, languages ?? null);
+}
+async function describe(id, maxLabels = 5) {
+  if (!native) throw new Error("ada-vision native module not present in this build");
+  return native.describe(id, maxLabels);
+}
+async function detectObjects(id, maxItems = 10, minConfidence = 0.25) {
+  if (!native) throw new Error("ada-vision native module not present in this build");
+  return native.detectObjects(id, maxItems, minConfidence);
+}
+
+// src/maps/index.ts
+var import_react_native3 = require("react-native");
+var import_expo_modules_core2 = require("expo-modules-core");
+var ExpoLocation2 = __toESM(require("expo-location"));
+
+// src/args.ts
+var shown = (v) => {
+  let s;
+  try {
+    s = JSON.stringify(v, (_k, x) => typeof x === "number" && !Number.isFinite(x) ? `
${x}
` : x)?.replace(/"\\u0001(NaN|-?Infinity)\\u0001"/g, "$1");
+  } catch {
+  }
+  s = s ?? String(v);
+  return s.length > 80 ? `${s.slice(0, 77)}...` : s;
+};
+function refuseArgument(capability, verb, problem, nothing) {
+  const e = new Error(`${capability}.${verb}: ${problem}; ${nothing}.`);
+  e.code = "INVALID_ARGUMENT";
+  return e;
+}
+function countArg(capability, verb, name, value, def, max, nothing) {
+  const v = value ?? def;
+  if (typeof v !== "number" || !Number.isFinite(v) || v < 1) {
+    throw refuseArgument(capability, verb, `${name} must be a number from 1 (at most ${max} are used), not ${shown(value)}`, nothing);
+  }
+  return Math.min(max, Math.floor(v));
+}
+function fractionArg(capability, verb, name, value, def, nothing) {
+  const v = value ?? def;
+  if (typeof v !== "number" || !Number.isFinite(v) || v < 0 || v > 1) {
+    throw refuseArgument(capability, verb, `${name} must be a number from 0 to 1, not ${shown(value)}`, nothing);
+  }
+  return v;
+}
+
+// src/maps/normalize.ts
+var SEARCH_RADIUS_DEFAULT_M = 3e3;
+var SEARCH_RADIUS_MAX_M = 1e5;
+var SEARCH_LIMIT_DEFAULT = 8;
+var SEARCH_LIMIT_MAX = 25;
+var text = (v) => typeof v === "string" && v.trim() !== "" ? v : null;
+var refuseArgument2 = (verb, problem, nothing) => refuseArgument("maps", verb, problem, nothing);
+function coordinateArg(verb, name, value, nothing) {
+  const c = value;
+  const latitude = c?.latitude, longitude = c?.longitude;
+  if (typeof latitude === "number" && Number.isFinite(latitude) && Math.abs(latitude) <= 90 && typeof longitude === "number" && Number.isFinite(longitude) && Math.abs(longitude) <= 180) {
+    return { latitude, longitude };
+  }
+  throw refuseArgument2(
+    verb,
+    `${name} must be { latitude, longitude } numbers (latitude -90..90, longitude -180..180), not ${shown(value)}`,
+    nothing
+  );
+}
+function searchArgs(query, opts) {
+  const nothing = "nothing was searched";
+  if (typeof query !== "string" || query.trim() === "") {
+    throw refuseArgument2("search", `query must be a non-empty string, not ${shown(query)}`, nothing);
+  }
+  const near = opts?.near == null ? null : coordinateArg("search", "near", opts.near, nothing);
+  const radiusM = opts?.radiusM ?? SEARCH_RADIUS_DEFAULT_M;
+  if (typeof radiusM !== "number" || !(radiusM > 0 && radiusM <= SEARCH_RADIUS_MAX_M)) {
+    throw refuseArgument2(
+      "search",
+      `radiusM must be metres above 0 and at most ${SEARCH_RADIUS_MAX_M}, not ${shown(radiusM)}`,
+      nothing
+    );
+  }
+  const limit = countArg("maps", "search", "limit", opts?.limit, SEARCH_LIMIT_DEFAULT, SEARCH_LIMIT_MAX, nothing);
+  return { query, near, radiusM, limit };
+}
+var point = (c) => ({
+  latitude: Number(c.latitude),
+  longitude: Number(c.longitude)
+});
+function toMapsAddress(raw) {
+  const r = raw ?? {};
+  return {
+    name: text(r.name),
+    street: text(r.street),
+    streetNumber: text(r.streetNumber),
+    district: text(r.district),
+    city: text(r.city),
+    region: text(r.region),
+    postalCode: text(r.postalCode),
+    country: text(r.country),
+    isoCountryCode: text(r.isoCountryCode)
+  };
+}
+function toMapsCategory(raw) {
+  const c = text(raw);
+  return c ? c.replace(/^MKPOICategory/, "") || null : null;
+}
+function toMapsPlaces(raw, near) {
+  return (raw ?? []).map((r) => {
+    const coordinate = point(r);
+    return {
+      name: text(r.name),
+      coordinate,
+      address: toMapsAddress(r.address),
+      category: toMapsCategory(r.category),
+      distanceM: near ? distanceOf([near, coordinate]) : null
+    };
+  });
+}
+function toReverseGeocodedPlace(at, address) {
+  return {
+    name: address.name,
+    coordinate: point(at),
+    address,
+    category: null,
+    distanceM: null
+  };
+}
+function toMapsRoute(raw) {
+  const steps = (raw.steps ?? []).map((s) => ({
+    instructions: typeof s.instructions === "string" ? s.instructions : "",
+    distanceM: Number(s.distance),
+    notice: text(s.notice),
+    polyline: (s.polyline ?? []).map(point)
+  }));
+  return {
+    mode: "walking",
+    distanceM: Number(raw.distance),
+    expectedTravelTimeMs: Math.round(Number(raw.expectedTravelTime) * 1e3),
+    steps,
+    polyline: (raw.polyline ?? []).map(point)
+  };
+}
+function mapsFailure(verb, err) {
+  const nativeCode = String(err?.code ?? "");
+  const detail = String(err?.message ?? err ?? "").trim();
+  let code;
+  let why;
+  if (nativeCode === "THROTTLED") {
+    code = "THROTTLED";
+    why = "Apple is rate-limiting map requests from this app \u2014 wait before retrying";
+  } else if (nativeCode === "OFFLINE") {
+    code = "OFFLINE";
+    why = "the map service could not be reached \u2014 the phone may be offline";
+  } else if (nativeCode === "ERR_GEOCODING_NETWORK") {
+    code = "OFFLINE";
+    why = "the geocoder could not be reached \u2014 the phone may be offline, or Apple is rate-limiting requests (iOS reports both the same way)";
+  } else {
+    code = "UNAVAILABLE";
+    why = "the map service failed";
+  }
+  const failure = new Error(
+    `maps.${verb} could not look: ${why}. This is not "found nothing".` + (detail ? ` (${nativeCode ? nativeCode + ": " : ""}${detail})` : "")
+  );
+  failure.code = code;
+  return failure;
+}
+
+// src/maps/index.ts
+var native2 = (0, import_expo_modules_core2.requireOptionalNativeModule)("AdaMaps");
+function missingReason() {
+  if (import_react_native3.Platform.OS !== "ios") return `iOS (Apple MapKit) \u2014 ${import_react_native3.Platform.OS} has no implementation yet`;
+  if (!native2) return "the app build with the AdaMaps module (this build predates it \u2014 a native rebuild is needed)";
+  return null;
+}
+function isSupported2() {
+  try {
+    return missingReason() === null && (native2?.isSupported() ?? false);
+  } catch {
+    return false;
+  }
+}
+async function search(query, near, radiusM, limit) {
+  if (!native2) throw new Error("ada-maps native module not present in this build");
+  return near ? native2.search(query, near.latitude, near.longitude, true, radiusM, limit) : native2.search(query, 0, 0, false, radiusM, limit);
+}
+async function route(from, to) {
+  if (!native2) throw new Error("ada-maps native module not present in this build");
+  return native2.route(from.latitude, from.longitude, to.latitude, to.longitude);
+}
+async function reverseGeocode(at) {
+  const [first] = await ExpoLocation2.reverseGeocodeAsync({ latitude: at.latitude, longitude: at.longitude });
+  return first ? toMapsAddress(first) : null;
+}
+
+// src/device-bridge/actions/messaging.ts
+var SMS = __toESM(require("expo-sms"));
+
+// src/device-bridge/actions/calendar-actions.ts
+var ExpoCalendar = __toESM(require("expo-calendar"));
+
+// src/device-bridge/actions/navigation.ts
+var Linking = __toESM(require("expo-linking"));
+var import_react_native4 = require("react-native");
+
+// src/device-bridge/collectors/health.ts
+var import_react_native5 = require("react-native");
+
+// src/device-bridge/background.ts
+var TaskManager = __toESM(require("expo-task-manager"));
+var BackgroundFetch = __toESM(require("expo-background-fetch"));
+
+// src/device-bridge/collectors/calendar.ts
+var ExpoCalendar2 = __toESM(require("expo-calendar"));
+
+// src/device-bridge/collectors/contacts.ts
+var ExpoContacts = __toESM(require("expo-contacts"));
+var import_async_storage4 = __toESM(require("@react-native-async-storage/async-storage"));
+
+// src/device-bridge/collectors/location.ts
+var location_exports = {};
+__export(location_exports, {
+  collectCurrent: () => collectCurrent,
+  getPosition: () => getPosition,
+  hasPermission: () => hasPermission,
+  requestPermission: () => requestPermission,
+  watchPosition: () => watchPosition
+});
+var ExpoLocation3 = __toESM(require("expo-location"));
+async function requestPermission() {
+  const { status: fg } = await ExpoLocation3.requestForegroundPermissionsAsync();
+  if (fg !== "granted") return false;
+  try {
+    await ExpoLocation3.requestBackgroundPermissionsAsync();
+  } catch {
+  }
+  return fg === "granted";
+}
+async function hasPermission() {
+  const { status } = await ExpoLocation3.getForegroundPermissionsAsync();
+  return status === "granted";
+}
+async function collectCurrent() {
+  const location = await ExpoLocation3.getCurrentPositionAsync({
+    accuracy: ExpoLocation3.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);
+    }
+  } 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 hasPermission()) return;
+  const granted = await requestPermission();
+  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 ExpoLocation3.getCurrentPositionAsync({
+    accuracy: opts.accuracy === "high" ? ExpoLocation3.Accuracy.High : ExpoLocation3.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: ExpoLocation3.Accuracy.BestForNavigation,
+  high: ExpoLocation3.Accuracy.High,
+  balanced: ExpoLocation3.Accuracy.Balanced,
+  low: ExpoLocation3.Accuracy.Low
+};
+function watchPosition(cb, opts) {
+  let subscription = null;
+  let cancelled = false;
+  (async () => {
+    try {
+      await ensurePermission();
+      if (cancelled) return;
+      subscription = await ExpoLocation3.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 classifyLocation(geocoded) {
+  const name = (geocoded.name || "").toLowerCase();
+  const street = (geocoded.street || "").toLowerCase();
+  if (name.includes("home") || name.includes("residence")) return "home";
+  if (name.includes("office") || name.includes("workplace") || name.includes("tech park")) return "work";
+  if (name.includes("school") || name.includes("elementary") || name.includes("university")) return "school";
+  if (name.includes("gym") || name.includes("fitness")) return "fitness";
+  if (name.includes("hospital") || name.includes("clinic") || name.includes("dental")) return "medical";
+  return "other";
+}
+
+// src/device-bridge/collectors/battery.ts
+var ExpoBattery2 = __toESM(require("expo-battery"));
+
+// src/device-bridge/collectors/connectivity.ts
+var connectivity_exports = {};
+__export(connectivity_exports, {
+  collectConnectivity: () => collectConnectivity
+});
+var ExpoNetwork = __toESM(require("expo-network"));
+async function collectConnectivity() {
+  const networkState = await ExpoNetwork.getNetworkStateAsync();
+  let type = "none";
+  let wifiName;
+  let cellularType;
+  if (networkState.type === ExpoNetwork.NetworkStateType.WIFI) {
+    type = "wifi";
+    try {
+      wifiName = await getWifiName();
+    } catch {
+      wifiName = void 0;
+    }
+  } else if (networkState.type === ExpoNetwork.NetworkStateType.CELLULAR) {
+    type = "cellular";
+    cellularType = getCellularGeneration();
+  }
+  return {
+    ok: true,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    connectivity: {
+      type,
+      is_connected: networkState.isConnected ?? false,
+      ...wifiName && { wifi_name: wifiName },
+      ...cellularType && { cellular_type: cellularType }
+    }
+  };
+}
+async function getWifiName() {
+  return void 0;
+}
+function getCellularGeneration() {
+  return "LTE";
+}
+
+// src/device-bridge/collectors/notifications.ts
+var ExpoNotifications = __toESM(require("expo-notifications"));
+
+// src/device-bridge/collectors/appEngagement.ts
+var import_react_native6 = require("react-native");
+var import_async_storage5 = __toESM(require("@react-native-async-storage/async-storage"));
+
+// src/device-bridge/collectors/camera.ts
+var import_expo_camera2 = require("expo-camera");
+
+// src/device-bridge/biometrics.ts
+var biometrics_exports = {};
+__export(biometrics_exports, {
+  authenticate: () => authenticate,
+  capabilities: () => capabilities
+});
+var LocalAuthentication = __toESM(require("expo-local-authentication"));
+async function capabilities() {
+  const [hasHardware, isEnrolled, types] = await Promise.all([
+    LocalAuthentication.hasHardwareAsync(),
+    LocalAuthentication.isEnrolledAsync(),
+    LocalAuthentication.supportedAuthenticationTypesAsync()
+  ]);
+  const supportedTypes = types.map((t) => {
+    if (t === LocalAuthentication.AuthenticationType.FINGERPRINT) return "fingerprint";
+    if (t === LocalAuthentication.AuthenticationType.FACIAL_RECOGNITION) return "face";
+    if (t === LocalAuthentication.AuthenticationType.IRIS) return "iris";
+    return "none";
+  }).filter((t) => t !== "none");
+  return { hasHardware, isEnrolled, supportedTypes };
+}
+async function authenticate(opts) {
+  try {
+    const res = await LocalAuthentication.authenticateAsync({
+      promptMessage: opts.reason,
+      cancelLabel: opts.cancelLabel,
+      disableDeviceFallback: opts.fallbackToPasscode === false
+    });
+    if (res.success) return { success: true };
+    return { success: false, error: res.error || "unknown" };
+  } catch (e) {
+    return { success: false, error: String(e?.message || e) };
+  }
+}
+
+// src/device-bridge/sharing.ts
+var sharing_exports = {};
+__export(sharing_exports, {
+  isAvailable: () => isAvailable,
+  shareFile: () => shareFile
+});
+var Sharing = __toESM(require("expo-sharing"));
+async function shareFile(fileUri, opts = {}) {
+  try {
+    const available = await Sharing.isAvailableAsync();
+    if (!available) return { ok: false, error: "sharing_unavailable" };
+    await Sharing.shareAsync(fileUri, opts);
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: String(e?.message || e) };
+  }
+}
+async function isAvailable() {
+  return Sharing.isAvailableAsync();
+}
+
+// src/device-bridge/scanner.ts
+var scanner_exports = {};
+__export(scanner_exports, {
+  CameraView: () => import_expo_camera3.CameraView,
+  normalizeResult: () => normalizeResult,
+  requestPermissions: () => requestPermissions,
+  useCameraPermissions: () => import_expo_camera3.useCameraPermissions
+});
+var import_expo_camera3 = require("expo-camera");
+async function requestPermissions() {
+  const { Camera: Camera2 } = await import("expo-camera");
+  const { status } = await Camera2.requestCameraPermissionsAsync();
+  return { granted: status === "granted", status };
+}
+function normalizeResult(r) {
+  return { type: r.type, data: r.data };
+}
+
+// src/device/createDeviceProvider.ts
+function getDeviceCookies() {
+  try {
+    return init_cookies(), __toCommonJS(cookies_exports);
+  } catch {
+    return null;
+  }
+}
+function getDeviceNfc() {
+  try {
+    return init_nfc(), __toCommonJS(nfc_exports);
+  } catch {
+    return null;
+  }
+}
+var CapabilityUnavailableError = class extends Error {
+  constructor(capability, reason) {
+    super(reason || `${capability} is not yet implemented. Coming in Phase 2.`);
+    this.code = "UNAVAILABLE";
+    this.name = "CapabilityUnavailableError";
+  }
+};
+function stubApi(capability) {
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (typeof prop === "string") {
+        return () => {
+          throw new CapabilityUnavailableError(capability);
+        };
+      }
+    }
+  });
+}
+function createLocationAPI() {
+  const ensurePermission2 = async () => {
+    const existing = await ExpoLocation4.getForegroundPermissionsAsync();
+    if (existing.status === "granted") return;
+    const asked = await ExpoLocation4.requestForegroundPermissionsAsync();
+    if (asked.status !== "granted") {
+      throw new Error(
+        "Location permission was not granted. Enable it for this app in Settings > Privacy > Location Services."
+      );
+    }
+  };
+  return {
+    async getCurrent(opts) {
+      await ensurePermission2();
+      const fix = await ExpoLocation4.getCurrentPositionAsync({
+        accuracy: opts?.accuracy === "high" ? ExpoLocation4.Accuracy.High : ExpoLocation4.Accuracy.Balanced
+      });
+      return {
+        latitude: fix.coords.latitude,
+        longitude: fix.coords.longitude,
+        altitude: fix.coords.altitude ?? void 0
+      };
+    },
+    watchPosition(cb) {
+      let subscription = null;
+      let cancelled = false;
+      void (async () => {
+        try {
+          await ensurePermission2();
+          if (cancelled) return;
+          subscription = await ExpoLocation4.watchPositionAsync(
+            { accuracy: ExpoLocation4.Accuracy.Balanced },
+            (fix) => cb({ latitude: fix.coords.latitude, longitude: fix.coords.longitude })
+          );
+          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 createCameraAPI() {
+  const ensurePermission2 = async () => {
+    const existing = await ImagePicker.getCameraPermissionsAsync();
+    if (existing.granted) return;
+    const asked = await ImagePicker.requestCameraPermissionsAsync();
+    if (!asked.granted) {
+      throw new Error(
+        "Camera permission was not granted. Enable it for this app in Settings > Privacy > Camera."
+      );
+    }
+  };
+  return {
+    async takePhoto(opts) {
+      await ensurePermission2();
+      const res = await ImagePicker.launchCameraAsync({
+        quality: opts?.quality ?? 0.7,
+        cameraType: opts?.facing === "front" ? ImagePicker.CameraType.front : ImagePicker.CameraType.back
+      });
+      if (res.canceled || !res.assets?.[0]) {
+        throw new Error("No photo taken \u2014 the camera was dismissed.");
+      }
+      const a = res.assets[0];
+      return { uri: a.uri, width: a.width, height: a.height };
+    },
+    async scanBarcode(opts) {
+      throw new CapabilityUnavailableError(
+        "camera.scanBarcode",
+        "Use native.scanner.scanOnce() instead \u2014 scanning needs a mounted camera, which this call cannot provide. Same arguments, and it returns { data, format }." + (opts?.formats?.length ? " Pass your formats through to scanOnce." : "")
+      );
+    },
+    async recordVideo(opts) {
+      return cameraTasks.run("record", {
+        maxDurationMs: opts?.maxDurationMs,
+        withAudio: opts?.withAudio ?? false
+      });
+    },
+    async pickImage(opts) {
+      const existing = await ImagePicker.getMediaLibraryPermissionsAsync();
+      if (!existing.granted) {
+        const asked = await ImagePicker.requestMediaLibraryPermissionsAsync();
+        if (!asked.granted) {
+          throw new Error(
+            "Photo library permission was not granted. Enable it for this app in Settings > Privacy > Photos."
+          );
+        }
+      }
+      const res = await ImagePicker.launchImageLibraryAsync({
+        allowsMultipleSelection: !!opts?.multiple
+      });
+      if (res.canceled) return [];
+      return (res.assets || []).map((a) => ({ uri: a.uri }));
+    }
+  };
+}
+var _pluginDbs = /* @__PURE__ */ new Map();
+function openPluginDb(file) {
+  const existing = _pluginDbs.get(file);
+  if (existing) return existing;
+  const opened = SQLite.openDatabaseAsync(file);
+  _pluginDbs.set(file, opened);
+  return opened;
+}
+function sqlLeadingKeyword(sql) {
+  let s = String(sql);
+  for (; ; ) {
+    const before = s;
+    s = s.replace(/^\s+/, "");
+    if (s.startsWith("--")) {
+      const nl = s.indexOf("\n");
+      s = nl === -1 ? "" : s.slice(nl + 1);
+    } else if (s.startsWith("/*")) {
+      const end = s.indexOf("*/");
+      s = end === -1 ? "" : s.slice(end + 2);
+    }
+    if (s === before) break;
+  }
+  const m = s.match(/^[A-Za-z]+/);
+  return m ? m[0].toUpperCase() : "";
+}
+function createStorageAPI(pluginId) {
+  const ns = encodeURIComponent(pluginId);
+  const key = (k) => `@plugin:${ns}:${k}`;
+  const dbFile = `plugin-storage-${ns}.db`;
+  return {
+    get: (k) => import_async_storage6.default.getItem(key(k)),
+    set: (k, v) => import_async_storage6.default.setItem(key(k), v),
+    delete: (k) => import_async_storage6.default.removeItem(key(k)),
+    db: {
+      async execute(sql, params) {
+        const verb = sqlLeadingKeyword(sql);
+        if (verb === "ATTACH" || verb === "DETACH" || verb === "VACUUM") {
+          throw new CapabilityUnavailableError(
+            "storage.db",
+            `SQL '${verb}' is not permitted: a plugin's storage is confined to its own database and cannot reach another file.`
+          );
+        }
+        const db = await openPluginDb(dbFile);
+        const returnsRows = verb === "SELECT" || verb === "PRAGMA" || verb === "WITH";
+        if (returnsRows) {
+          const rows = await db.getAllAsync(sql, params ?? []);
+          return { rows, changes: 0 };
+        }
+        const res = await db.runAsync(sql, params ?? []);
+        return { rows: [], changes: res.changes ?? 0 };
+      }
+    }
+  };
+}
+function createNotificationsAPI() {
+  return {
+    async schedule({ title, body, trigger }) {
+      const perm = await Notifications.getPermissionsAsync();
+      if (!perm.granted) {
+        const asked = await Notifications.requestPermissionsAsync();
+        if (!asked.granted) {
+          throw new Error(
+            "Notification permission was not granted. Enable it for this app in Settings > Notifications."
+          );
+        }
+      }
+      const when = typeof trigger?.seconds === "number" ? { type: "timeInterval", seconds: trigger.seconds, repeats: false } : trigger?.date ? { type: "date", date: new Date(trigger.date) } : null;
+      if (!when) {
+        throw new Error("schedule() needs trigger.seconds or trigger.date.");
+      }
+      return Notifications.scheduleNotificationAsync({
+        content: { title, body },
+        trigger: when
+      });
+    },
+    cancel: (id) => Notifications.cancelScheduledNotificationAsync(id),
+    onReceived(cb) {
+      const sub2 = Notifications.addNotificationReceivedListener((n) => {
+        cb({
+          id: n.request.identifier,
+          title: n.request.content.title || "",
+          body: n.request.content.body || "",
+          data: n.request.content.data
+        });
+      });
+      return () => sub2.remove();
+    }
+  };
+}
+function createFileSystemAPI(pluginId) {
+  let _root = null;
+  const rootDir = () => _root ?? (_root = new FS.Directory(FS.Paths.document, "plugin-files", pluginId));
+  const resolve = (p) => {
+    const root = rootDir();
+    const file = new FS.File(root, p);
+    if (!file.uri.startsWith(root.uri)) {
+      throw new CapabilityUnavailableError(
+        "fileSystem",
+        `Path escapes the plugin's storage area: ${p}. Plugin files live under plugin-files/ and paths cannot traverse out of it.`
+      );
+    }
+    return file;
+  };
+  return {
+    async readFile(path) {
+      const file = resolve(path);
+      if (!file.exists) {
+        throw new CapabilityUnavailableError(
+          "fileSystem.readFile",
+          `No such file: ${path}. Nothing was read.`
+        );
+      }
+      return file.text();
+    },
+    async writeFile(path, content) {
+      const file = resolve(path);
+      const parent = file.parentDirectory;
+      if (!parent.exists) parent.create({ intermediates: true });
+      if (!file.exists) file.create();
+      file.write(content);
+    },
+    async pickDocument(opts) {
+      const res = await DocumentPicker.getDocumentAsync({
+        type: opts?.types?.length ? opts.types : "*/*",
+        copyToCacheDirectory: true
+      });
+      if (res.canceled || !res.assets?.[0]) {
+        throw new Error("No document chosen \u2014 the picker was dismissed.");
+      }
+      const a = res.assets[0];
+      return { uri: a.uri, name: a.name, size: a.size ?? 0 };
+    }
+  };
+}
+function createHapticsAPI() {
+  return {
+    impact(style) {
+      const map = {
+        light: Haptics2.ImpactFeedbackStyle.Light,
+        medium: Haptics2.ImpactFeedbackStyle.Medium,
+        heavy: Haptics2.ImpactFeedbackStyle.Heavy
+      };
+      Haptics2.impactAsync(map[style]);
+    },
+    notification(type) {
+      const map = {
+        success: Haptics2.NotificationFeedbackType.Success,
+        warning: Haptics2.NotificationFeedbackType.Warning,
+        error: Haptics2.NotificationFeedbackType.Error
+      };
+      Haptics2.notificationAsync(map[type]);
+    },
+    // Shorthand for notification('error'). Plugins call this; it was never
+    // implemented, and optional chaining meant the failure the user was meant
+    // to FEEL simply did not happen.
+    error() {
+      Haptics2.notificationAsync(Haptics2.NotificationFeedbackType.Error);
+    },
+    selection() {
+      Haptics2.selectionAsync();
+    }
+  };
+}
+function createConnectivityAPI(reachabilityUrl) {
+  let online = true;
+  const listeners = /* @__PURE__ */ new Set();
+  let interval = null;
+  const checkOnline = async () => {
+    if (!reachabilityUrl) return true;
+    try {
+      const res = await fetch(reachabilityUrl, {
+        method: "HEAD",
+        signal: AbortSignal.timeout(5e3)
+      });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  };
+  const startPolling = () => {
+    if (!reachabilityUrl) return;
+    if (interval) return;
+    interval = setInterval(async () => {
+      const newState = await checkOnline();
+      if (newState !== online) {
+        online = newState;
+        listeners.forEach((cb) => cb(online));
+      }
+    }, 3e4);
+  };
+  return {
+    isOnline() {
+      return online;
+    },
+    onChange(cb) {
+      listeners.add(cb);
+      startPolling();
+      return () => {
+        listeners.delete(cb);
+        if (listeners.size === 0 && interval) {
+          clearInterval(interval);
+          interval = null;
+        }
+      };
+    }
+  };
+}
+function createCookiesAPI() {
+  return {
+    async get(url) {
+      const mod = getDeviceCookies();
+      if (!mod) throw new CapabilityUnavailableError("cookies (native module not available \u2014 use a dev build)");
+      const list = await mod.get(url, true);
+      return list;
+    },
+    async clear(_url) {
+      const mod = getDeviceCookies();
+      if (!mod) throw new CapabilityUnavailableError("cookies (native module not available \u2014 use a dev build)");
+      const r = await mod.clearAll();
+      return { ok: r.ok };
+    }
+  };
+}
+function createBiometricsAPIv2() {
+  return {
+    capabilities: () => biometrics_exports.capabilities(),
+    authenticate: (opts) => biometrics_exports.authenticate(opts)
+  };
+}
+function createSharingAPI() {
+  return {
+    isAvailable: () => sharing_exports.isAvailable(),
+    shareFile: (fileUri, opts) => sharing_exports.shareFile(fileUri, opts)
+  };
+}
+function createScannerAPI() {
+  return {
+    requestPermissions: () => scanner_exports.requestPermissions(),
+    // Raises the shared camera surface and settles on the first code read.
+    // The plugin mounts nothing — that lifecycle is owned once, by
+    // CameraTaskHost, instead of by every plugin that wants to scan.
+    scanOnce: (opts) => cameraTasks.run("scan", {
+      formats: opts?.formats,
+      timeoutMs: opts?.timeoutMs
+    })
+  };
+}
+function createNfcAPI() {
+  return {
+    async isSupported() {
+      const mod = getDeviceNfc();
+      if (!mod) return false;
+      return mod.isSupported();
+    },
+    async isEnabled() {
+      const mod = getDeviceNfc();
+      if (!mod) return false;
+      return mod.isEnabled();
+    },
+    readOnce(timeoutMs) {
+      const mod = getDeviceNfc();
+      if (!mod) return Promise.resolve({ ok: false, error: "nfc_unavailable" });
+      return mod.readOnce(timeoutMs);
+    }
+  };
+}
+function createBluetoothAPI() {
+  const refuse = (method) => new CapabilityUnavailableError(
+    `bluetooth.${method}`,
+    "Bluetooth is not implemented in this build \u2014 no BLE native module is installed. The capability is declared so it fails by name rather than silently; nothing was scanned."
+  );
+  return {
+    // These two answer `false` rather than throwing, because "is BLE usable?"
+    // is exactly the question a plugin should be allowed to ask before
+    // committing to a flow, and `false` is the true answer here.
+    async isSupported() {
+      return false;
+    },
+    async isEnabled() {
+      return false;
+    },
+    // scan() THROWS, because there is no honest empty result: an empty device
+    // list is a real finding ("nothing is advertising nearby") and returning
+    // one would report a scan that never happened.
+    async scan() {
+      throw refuse("scan");
+    }
+  };
+}
+function createVisionAPI() {
+  return {
+    // "Can I see?" — true once the native module is present in the binary. On a
+    // build without it, adaVision.isSupported() answers false, and assessQuality
+    // below refuses cleanly (no crash), exactly the pre-module behaviour.
+    async isSupported() {
+      return isSupported();
+    },
+    // readText: on-device OCR on a published frame (native resolves the id →
+    // pixels). [] = looked, found no text (a real finding); throws = could not
+    // look (unknown/aged-out id). describe (VNClassifyImage) is the next pass.
+    async readText(frameId, opts) {
+      const langs = opts?.languages;
+      if (langs != null && (!Array.isArray(langs) || langs.some((l) => typeof l !== "string"))) {
+        throw refuseArgument("vision", "readText", `languages must be an array of language codes, not ${shown(langs)}`, "nothing was read");
+      }
+      return readText(frameId, langs);
+    },
+    // describe: on-device labels (VNClassifyImage), not prose — the sentence is
+    // the skill's job. [] = looked, recognised nothing.
+    async describe(frameId, opts) {
+      return describe(frameId, countArg("vision", "describe", "maxLabels", opts?.maxLabels, 5, 50, "nothing was labelled"));
+    },
+    // detectObjects: on-device located objects (bundled detector), each with a
+    // box — what a guidance loop reads to say WHERE a thing is, not just that the
+    // scene contains it. [] = looked, found nothing; throws = could not look.
+    async detectObjects(frameId, opts) {
+      const nothing = "nothing was detected";
+      return detectObjects(
+        frameId,
+        countArg("vision", "detectObjects", "maxItems", opts?.maxItems, 10, 50, nothing),
+        fractionArg("vision", "detectObjects", "minConfidence", opts?.minConfidence, 0.25, nothing)
+      );
+    },
+    // assessQuality: resolve the frame id to its LOCAL file, measure on-device,
+    // and record the result back onto the frame so a later read of
+    // VisualFrameRef.quality reflects it. Throwing here means "could not look"
+    // (unknown/aged-out id, or no native module) — never a measured verdict.
+    async assessQuality(frameId) {
+      const q = qualityById(frameId);
+      if (!q) {
+        throw new CapabilityUnavailableError(
+          "vision.assessQuality",
+          `No frame for id "${frameId}" \u2014 unknown or aged out of the ring. This is "could not look", not a measurement.`
+        );
+      }
+      return q;
+    }
+  };
+}
+function createMapsAPI() {
+  const refuseIfMissing = (verb, nothing) => {
+    const missing = missingReason();
+    if (missing) {
+      throw new CapabilityUnavailableError(`maps.${verb}`, `maps.${verb} needs ${missing}; ${nothing}.`);
+    }
+  };
+  return {
+    async isSupported() {
+      return isSupported2();
+    },
+    // [] = Apple looked and found nothing (a real finding); throws = could not
+    // look. The defaults (radiusM 3000, limit 8) live in searchArgs.
+    async search(query, opts) {
+      const args = searchArgs(query, opts);
+      refuseIfMissing("search", "nothing was searched");
+      const raw = await search(args.query, args.near, args.radiusM, args.limit).catch((err) => {
+        throw mapsFailure("search", err);
+      });
+      return toMapsPlaces(raw, args.near);
+    },
+    // null = nothing at that point; throws = could not look.
+    async reverseGeocode(at) {
+      const point2 = coordinateArg("reverseGeocode", "at", at, "nothing was looked up");
+      const address = await reverseGeocode(point2).catch((err) => {
+        throw mapsFailure("reverseGeocode", err);
+      });
+      return address ? toReverseGeocodedPlace(point2, address) : null;
+    },
+    // null = Apple found no route. Never an empty 0 m route, which would read as
+    // "you have arrived". A remote bundle can pass any string as `mode`, so a
+    // mode this build cannot honour refuses rather than silently walking.
+    async route(from, to, opts) {
+      if (opts?.mode !== void 0 && opts.mode !== "walking") {
+        throw new CapabilityUnavailableError(
+          "maps.route",
+          `maps.route supports walking only, not "${String(opts.mode)}"; no route was requested.`
+        );
+      }
+      const a = coordinateArg("route", "from", from, "no route was requested");
+      const b = coordinateArg("route", "to", to, "no route was requested");
+      refuseIfMissing("route", "no route was requested");
+      const raw = await route(a, b).catch((err) => {
+        throw mapsFailure("route", err);
+      });
+      return raw ? toMapsRoute(raw) : null;
+    }
+  };
+}
+function createDeviceProvider(config) {
+  const connectivity = createConnectivityAPI(config?.reachabilityUrl);
+  return {
+    camera: createCameraAPI(),
+    location: createLocationAPI(),
+    // Only the per-plugin storageFor/fileSystemFor are exposed — NO shared
+    // `storage`/`fileSystem` bucket. The gate scopes by pluginId and fails
+    // closed without one, so a shared instance would be an unreachable
+    // (and dangerous) fallback. Each plugin gets its own namespace + db file /
+    // sandbox directory, or nothing.
+    storageFor: (pluginId) => createStorageAPI(pluginId),
+    biometrics: stubApi("biometrics"),
+    biometricsV2: createBiometricsAPIv2(),
+    notifications: createNotificationsAPI(),
+    haptics: createHapticsAPI(),
+    connectivity,
+    fileSystemFor: (pluginId) => createFileSystemAPI(pluginId),
+    cookies: createCookiesAPI(),
+    sharing: createSharingAPI(),
+    scanner: createScannerAPI(),
+    nfc: createNfcAPI(),
+    bluetooth: createBluetoothAPI(),
+    vision: createVisionAPI(),
+    maps: createMapsAPI()
+  };
+}
+
+// src/oauth/expoOAuth.tsx
+var import_react_native7 = require("react-native");
+var import_google_signin = require("@react-native-google-signin/google-signin");
+var AppleAuthentication = __toESM(require("expo-apple-authentication"));
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var NOOP = () => {
+};
+function createExpoOAuthProvider(host = {}) {
+  return {
+    async signInWithGoogle(cfg) {
+      const webClientId = cfg?.webClientId || host.googleWebClientId || "";
+      const iosClientId = cfg?.iosClientId || host.googleIosClientId || "";
+      const params = { webClientId };
+      if (iosClientId) params.iosClientId = iosClientId;
+      import_google_signin.GoogleSignin.configure(params);
+      try {
+        await import_google_signin.GoogleSignin.hasPlayServices({ showPlayServicesUpdateDialog: true });
+        const result = await import_google_signin.GoogleSignin.signIn();
+        return result?.data?.idToken || result?.idToken || null;
+      } catch (err) {
+        const code = err?.code;
+        if (code === import_google_signin.statusCodes.SIGN_IN_CANCELLED || code === import_google_signin.statusCodes.IN_PROGRESS) {
+          return null;
+        }
+        throw err;
+      }
+    },
+    async signInWithApple() {
+      try {
+        const credential = await AppleAuthentication.signInAsync({
+          requestedScopes: [
+            AppleAuthentication.AppleAuthenticationScope.FULL_NAME,
+            AppleAuthentication.AppleAuthenticationScope.EMAIL
+          ]
+        });
+        return credential.identityToken || null;
+      } catch (err) {
+        if (err?.code === "ERR_REQUEST_CANCELED") return null;
+        throw err;
+      }
+    },
+    async isAppleAvailable() {
+      if (import_react_native7.Platform.OS !== "ios") return false;
+      try {
+        return await AppleAuthentication.isAvailableAsync();
+      } catch {
+        return false;
+      }
+    },
+    renderAppleButton({ onPress, disabled, style }) {
+      return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+        AppleAuthentication.AppleAuthenticationButton,
+        {
+          buttonType: AppleAuthentication.AppleAuthenticationButtonType.CONTINUE,
+          buttonStyle: AppleAuthentication.AppleAuthenticationButtonStyle.BLACK,
+          cornerRadius: 999,
+          style,
+          onPress: disabled ? NOOP : onPress
+        }
+      );
+    }
+  };
+}
+
+// src/bootstrap.ts
+function bootstrapExpoAdas(opts) {
+  const { attachmentCache } = setupExpoProviders({
+    bundleModules: opts.bundleModules,
+    attachmentIndexKey: opts.storageKeys?.attachmentIndex,
+    bundleIndexKey: opts.storageKeys?.bundleIndex,
+    deviceProvider: createDeviceProvider({ reachabilityUrl: opts.reachabilityUrl })
+  });
+  for (const plugin of opts.nativePlugins ?? []) {
+    for (const id of plugin.ids) (0, import_plugin_runtime3.registerNativePlugin)(id, plugin.resolver);
+  }
+  const relay = opts.urls.relay;
+  (0, import_ui2.setPluginWebViewExtraHosts)(() => relay ? [relay()] : []);
+  (0, import_ui2.setOAuthProvider)(createExpoOAuthProvider({ googleIosClientId: opts.googleIosClientId }));
+  if (opts.onReachabilityChange) {
+    const onReach = opts.onReachabilityChange;
+    (0, import_core2.setAcsReachabilityReporter)({ up: () => onReach(true), down: () => onReach(false) });
+  }
+  (0, import_plugin_runtime3.setDeviceStateProvider)(
+    createDeviceState({ connectivity: connectivity_exports, location: location_exports })
+  );
+  (0, import_plugin_runtime3.registerPlatformDeviceTools)();
+  (0, import_ui2.setUIActionNavigator)(opts.navigateToPlugin);
+  (0, import_core2.initAdas)({
+    coreUrl: opts.urls.core,
+    ...opts.urls.voice ? { voiceUrl: opts.urls.voice } : {},
+    ...opts.urls.consumerAuth ? { consumerAuthUrl: opts.urls.consumerAuth } : {},
+    ...opts.onSession ? { onSession: opts.onSession } : {},
+    ...opts.tenant ? { tenant: opts.tenant } : {},
+    getUser: opts.getUser,
+    tokenProvider: opts.tokenProvider,
+    attachmentCache
+  });
+  return { attachmentCache };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bootstrapExpoAdas
+});
+//# sourceMappingURL=bootstrap.js.map