@ateam-ai-mobile/expo 0.1.7 → 0.1.8

package/dist/bootstrap.js

@@ -94,7 +94,7 @@ var init_cookies = __esm({
 var nfc_exports = {};
 __export(nfc_exports, {
   isEnabled: () => isEnabled,
-  isSupported: () => isSupported2,
+  isSupported: () => isSupported3,
   readOnce: () => readOnce
 });
 async function ensureInit() {
@@ -109,7 +109,7 @@ async function ensureInit() {
     return false;
   }
 }
-async function isSupported2() {
+async function isSupported3() {
   try {
     return await import_react_native_nfc_manager.default.isSupported();
   } catch {
@@ -384,6 +384,30 @@ function unsupported(what) {
   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 {
@@ -419,11 +443,12 @@ function createDeviceContextDomain() {
     },
     // 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.
+    // 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({ type: "batteryLevelChanged" })),
-        ExpoBattery.addBatteryStateListener(() => listener({ type: "chargingChanged" }))
+        ExpoBattery.addBatteryLevelListener(() => listener(stateEvent("deviceContext", "batteryLevelChanged"))),
+        ExpoBattery.addBatteryStateListener(() => listener(stateEvent("deviceContext", "chargingChanged")))
       ];
       return { unsubscribe: () => subs.forEach((x) => x?.remove?.()) };
     }
@@ -559,13 +584,523 @@ function createInteractionDomain() {
     // which is the one part of this domain that works.
     subscribe(listener) {
       const sub2 = import_react_native.AppState.addEventListener("change", (next) => {
-        listener({ type: "appStateChanged", appState: mapState(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 },
@@ -779,300 +1314,26 @@ function frameQuality(frame) {
   };
 }
 
-// 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 turns = new TurnDetector();
-async function startHeading() {
-  if (sub) return;
-  try {
-    sub = await ExpoLocation.watchHeadingAsync((h) => {
-      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;
-      latest = { headingDeg: deg, calibration: cal, timestamp: Date.now() };
-      turns.push(deg, Date.now());
-    });
-  } catch {
-    sub = null;
-  }
-}
-function stopHeading() {
-  sub?.remove();
-  sub = null;
-  latest = null;
-  turns.reset();
-}
-function currentHeading() {
-  return latest ? { headingDeg: latest.headingDeg } : null;
-}
-function currentHeadingDetail() {
-  return latest;
-}
-function lastMeaningfulTurn() {
-  return turns.last();
-}
-
-// src/device-state/domains/spatial.ts
-function createSpatialDomain(collectors, speedRef) {
-  const RECENT_PATH_MAX = 60;
-  const STATIONARY_MPS = 0.4;
-  let recentPath = [];
-  let latest2 = null;
-  let latestSpeed = null;
-  let latestCourse = null;
-  let stopWatch = null;
-  let sessionId = 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);
-  };
+// src/device-state/domains/visual.ts
+function cameraState() {
+  const session = visualEngine.getSession();
   return {
-    async getSnapshot() {
-      let point = latest2;
-      let speedMps = latestSpeed;
-      let courseDeg = latestCourse;
-      let derived = false;
-      if (!point) {
-        try {
-          if (!collectors.location) throw unsupported("location collector");
-          const fix = await collectors.location.getPosition({ accuracy: "low" });
-          point = {
-            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 {
-            position: null,
-            movement: { speedMps: null, bearingDeg: null, distanceRecentM: null, state: "unknown" },
-            orientation: { headingDeg: null },
-            recentPath: [],
-            quality: qualityUnknown()
-          };
-        }
-      }
-      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: point,
-        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,
-          // Only claim stationary/moving when a speed was actually obtained.
-          // With no speed the truthful answer is `unknown`, not `stationary` —
-          // "you have stopped" is a false statement, not a neutral default.
-          state: speedMps === null ? "unknown" : speedMps < STATIONARY_MPS ? "stationary" : "moving"
-        },
-        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(
-          point.timestamp,
-          spatialConfidence(point.accuracyM ?? null, heading?.calibration ?? null, derived)
-        )
-      };
-    },
-    /**
-     * Open the warm window: position stream + compass.
-     *
-     * The intent is recorded but does NOT yet change sampling — no native
-     * strategy layer exists — so it is accepted rather than refused only
-     * because the streams it opens are real and useful.
-     */
-    async start(options) {
-      if (stopWatch) return { id: sessionId, intent: options.intent, startedAt: Date.now() };
-      sessionId = `spatial_${Date.now()}`;
-      if (!collectors.location) throw unsupported("location collector");
-      void startHeading();
-      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);
-      });
-      return { id: sessionId, intent: options.intent, startedAt: Date.now() };
-    },
-    async stop() {
-      stopWatch?.();
-      stopWatch = null;
-      sessionId = null;
-      recentPath = [];
-      latest2 = null;
-      latestSpeed = null;
-      latestCourse = null;
-      speedRef.mps = null;
-      speedRef.at = 0;
-      if (!visualEngine.getSession()) stopHeading();
-    },
-    // No event vocabulary is frozen for spatial, and inventing names here would
-    // put them in plugins before the freeze can contradict them.
-    subscribe() {
-      throw unsupported("spatial.subscribe");
-    }
+    // `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 spatialConfidence(accuracyM, calibration, derived) {
-  const rank = (v) => v === "high" ? 3 : v === "medium" ? 2 : v === "low" ? 1 : 0;
-  const fromFix = accuracyM === null ? "unknown" : accuracyM <= 10 ? "high" : accuracyM <= 50 ? "medium" : "low";
-  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;
-}
-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/domains/visual.ts
 function createVisualDomain() {
   return {
     async getSnapshot() {
-      const session = visualEngine.getSession();
       const latest2 = visualEngine.latest();
       const timeline = visualEngine.timeline();
       return {
-        camera: {
-          // `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"
-        },
+        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,
@@ -1083,13 +1344,13 @@ function createVisualDomain() {
     async start(options) {
       const s = visualEngine.startSession(options?.intent || "navigation");
       visualEngine.setContextProvider({ heading: currentHeading });
-      void startHeading();
+      void startHeading("visual");
       return { id: s.id, intent: s.intent, startedAt: s.startedAt };
     },
     async stop() {
       visualEngine.stopSession();
       visualEngine.setContextProvider(null);
-      stopHeading();
+      stopHeading("visual");
     },
     /**
      * A deliberate one-shot. Distinct from getSnapshot because it is an
@@ -1120,9 +1381,20 @@ function createVisualDomain() {
       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(() => {
-        listener({ type: "visualStateChanged" });
+        const camera = cameraState();
+        const key = JSON.stringify(camera);
+        if (key === last) return;
+        last = key;
+        listener(stateEvent("visual", "visualStateChanged", { camera }));
       });
       return { unsubscribe: off };
     }
@@ -1539,7 +1811,7 @@ function setupExpoProviders(opts) {
   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: (text) => ExpoClipboard.setStringAsync(text).then(() => {
+    setString: (text2) => ExpoClipboard.setStringAsync(text2).then(() => {
     })
   });
   (0, import_plugin_runtime2.registerBundleModules)({
@@ -1556,7 +1828,7 @@ function setupExpoProviders(opts) {
 
 // src/device/createDeviceProvider.ts
 var Haptics2 = __toESM(require("expo-haptics"));
-var ExpoLocation3 = __toESM(require("expo-location"));
+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"));
@@ -1598,6 +1870,187 @@ async function detectObjects(id, maxItems = 10, minConfidence = 0.25) {
   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"));
 
@@ -1606,10 +2059,10 @@ var ExpoCalendar = __toESM(require("expo-calendar"));
 
 // src/device-bridge/actions/navigation.ts
 var Linking = __toESM(require("expo-linking"));
-var import_react_native3 = require("react-native");
+var import_react_native4 = require("react-native");
 
 // src/device-bridge/collectors/health.ts
-var import_react_native4 = require("react-native");
+var import_react_native5 = require("react-native");
 
 // src/device-bridge/background.ts
 var TaskManager = __toESM(require("expo-task-manager"));
@@ -1631,29 +2084,29 @@ __export(location_exports, {
   requestPermission: () => requestPermission,
   watchPosition: () => watchPosition
 });
-var ExpoLocation2 = __toESM(require("expo-location"));
+var ExpoLocation3 = __toESM(require("expo-location"));
 async function requestPermission() {
-  const { status: fg } = await ExpoLocation2.requestForegroundPermissionsAsync();
+  const { status: fg } = await ExpoLocation3.requestForegroundPermissionsAsync();
   if (fg !== "granted") return false;
   try {
-    await ExpoLocation2.requestBackgroundPermissionsAsync();
+    await ExpoLocation3.requestBackgroundPermissionsAsync();
   } catch {
   }
   return fg === "granted";
 }
 async function hasPermission() {
-  const { status } = await ExpoLocation2.getForegroundPermissionsAsync();
+  const { status } = await ExpoLocation3.getForegroundPermissionsAsync();
   return status === "granted";
 }
 async function collectCurrent() {
-  const location = await ExpoLocation2.getCurrentPositionAsync({
-    accuracy: ExpoLocation2.Accuracy.Balanced
+  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 ExpoLocation2.reverseGeocodeAsync({
+    const geocoded = await reverseGeocode({
       latitude: location.coords.latitude,
       longitude: location.coords.longitude
     });
@@ -1692,8 +2145,8 @@ async function ensurePermission() {
 }
 async function getPosition(opts = {}) {
   await ensurePermission();
-  const fix = await ExpoLocation2.getCurrentPositionAsync({
-    accuracy: opts.accuracy === "high" ? ExpoLocation2.Accuracy.High : ExpoLocation2.Accuracy.Balanced
+  const fix = await ExpoLocation3.getCurrentPositionAsync({
+    accuracy: opts.accuracy === "high" ? ExpoLocation3.Accuracy.High : ExpoLocation3.Accuracy.Balanced
   });
   return toPosition(fix);
 }
@@ -1711,15 +2164,21 @@ function toPosition(fix) {
 function nonNegative(v) {
   return typeof v === "number" && v >= 0 ? v : void 0;
 }
-function watchPosition(cb) {
+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 ExpoLocation2.watchPositionAsync(
-        { accuracy: ExpoLocation2.Accuracy.Balanced },
+      subscription = await ExpoLocation3.watchPositionAsync(
+        { accuracy: WATCH_TIER[opts?.accuracy ?? "balanced"] },
         (fix) => cb(toPosition(fix))
       );
       if (cancelled) {
@@ -1794,7 +2253,7 @@ function getCellularGeneration() {
 var ExpoNotifications = __toESM(require("expo-notifications"));
 
 // src/device-bridge/collectors/appEngagement.ts
-var import_react_native5 = require("react-native");
+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
@@ -1909,9 +2368,9 @@ function stubApi(capability) {
 }
 function createLocationAPI() {
   const ensurePermission2 = async () => {
-    const existing = await ExpoLocation3.getForegroundPermissionsAsync();
+    const existing = await ExpoLocation4.getForegroundPermissionsAsync();
     if (existing.status === "granted") return;
-    const asked = await ExpoLocation3.requestForegroundPermissionsAsync();
+    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."
@@ -1921,8 +2380,8 @@ function createLocationAPI() {
   return {
     async getCurrent(opts) {
       await ensurePermission2();
-      const fix = await ExpoLocation3.getCurrentPositionAsync({
-        accuracy: opts?.accuracy === "high" ? ExpoLocation3.Accuracy.High : ExpoLocation3.Accuracy.Balanced
+      const fix = await ExpoLocation4.getCurrentPositionAsync({
+        accuracy: opts?.accuracy === "high" ? ExpoLocation4.Accuracy.High : ExpoLocation4.Accuracy.Balanced
       });
       return {
         latitude: fix.coords.latitude,
@@ -1937,8 +2396,8 @@ function createLocationAPI() {
         try {
           await ensurePermission2();
           if (cancelled) return;
-          subscription = await ExpoLocation3.watchPositionAsync(
-            { accuracy: ExpoLocation3.Accuracy.Balanced },
+          subscription = await ExpoLocation4.watchPositionAsync(
+            { accuracy: ExpoLocation4.Accuracy.Balanced },
             (fix) => cb({ latitude: fix.coords.latitude, longitude: fix.coords.longitude })
           );
           if (cancelled) {
@@ -2312,18 +2771,27 @@ function createVisionAPI() {
     // 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) {
-      return readText(frameId, opts?.languages);
+      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, opts?.maxLabels ?? 5);
+      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) {
-      return detectObjects(frameId, opts?.maxItems ?? 10, opts?.minConfidence ?? 0.25);
+      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
@@ -2341,6 +2809,55 @@ function createVisionAPI() {
     }
   };
 }
+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 {
@@ -2363,12 +2880,13 @@ function createDeviceProvider(config) {
     scanner: createScannerAPI(),
     nfc: createNfcAPI(),
     bluetooth: createBluetoothAPI(),
-    vision: createVisionAPI()
+    vision: createVisionAPI(),
+    maps: createMapsAPI()
   };
 }
 
 // src/oauth/expoOAuth.tsx
-var import_react_native6 = require("react-native");
+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");
@@ -2409,7 +2927,7 @@ function createExpoOAuthProvider(host = {}) {
       }
     },
     async isAppleAvailable() {
-      if (import_react_native6.Platform.OS !== "ios") return false;
+      if (import_react_native7.Platform.OS !== "ios") return false;
       try {
         return await AppleAuthentication.isAvailableAsync();
       } catch {