@ateam-ai-mobile/expo 0.1.5 → 0.1.8

package/dist/chunk-C7M5WAHA.mjs

@@ -0,0 +1,1798 @@
+import {
+  cameraError,
+  cameraTasks
+} from "./chunk-6LXF3JVX.mjs";
+import {
+  distanceOf
+} from "./chunk-J6XRNX7P.mjs";
+import {
+  __require
+} from "./chunk-WMJKH4XE.mjs";
+
+// src/index.ts
+import * as ExpoWebBrowser from "expo-web-browser";
+import * as ExpoLinking from "expo-linking";
+import * as ExpoClipboard from "expo-clipboard";
+import AsyncStorage3 from "@react-native-async-storage/async-storage";
+import { setAcsCacheStorage } from "@ateam-ai-mobile/core";
+import {
+  setHapticsProvider,
+  setBundleStorage,
+  registerBundleModules,
+  setPluginNativeProvider
+} from "@ateam-ai-mobile/plugin-runtime";
+import { setClipboardProvider } from "@ateam-ai-mobile/ui";
+
+// src/haptics.ts
+import * as Haptics from "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
+import * as FileSystem from "expo-file-system/legacy";
+import AsyncStorage from "@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 AsyncStorage.getItem(this.indexKey);
+      return raw ? JSON.parse(raw) : {};
+    } catch {
+      return {};
+    }
+  }
+  async saveIndex(index) {
+    try {
+      await AsyncStorage.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 AsyncStorage.removeItem(this.indexKey).catch(() => {
+    });
+    this.dirReady = false;
+  }
+};
+
+// src/attachmentCache.ts
+import * as FileSystem2 from "expo-file-system/legacy";
+import AsyncStorage2 from "@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 AsyncStorage2.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 AsyncStorage2.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
+import * as ExpoBattery from "expo-battery";
+
+// src/device-state/quality.ts
+import { neverObserved } from "@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: 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
+import { AppState } from "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(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 = AppState.addEventListener("change", (next) => {
+        listener(stateEvent("interaction", "appStateChanged", { appState: mapState(next) }));
+      });
+      return { unsubscribe: () => sub2.remove() };
+    }
+  };
+}
+
+// src/device-state/headingSource.ts
+import * as ExpoLocation from "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/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 nonNegative = (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 = (point, 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: 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,
+        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(
+        point.timestamp,
+        spatialConfidence(point.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 point;
+      let speedMps;
+      let courseDeg;
+      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: nonNegative(fix.accuracy),
+          timestamp: fix.timestamp ?? Date.now()
+        };
+        speedMps = nonNegative(fix.speed);
+        courseDeg = nonNegative(fix.course);
+      } catch {
+        return noFix();
+      }
+      return snapshotFrom(point, 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: nonNegative(pos.accuracy),
+          timestamp: pos.timestamp ?? Date.now()
+        };
+        latest2 = p;
+        latestSpeed = nonNegative(pos.speed);
+        latestCourse = nonNegative(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)
+  };
+}
+var IMPLEMENTED_DOMAINS = [
+  "deviceContext",
+  "connectivity",
+  "capability",
+  "interaction",
+  "spatial",
+  "visual",
+  "activity"
+];
+
+// src/camera/CameraTaskHost.tsx
+import { useEffect, useRef, useState } from "react";
+import { Pressable, StyleSheet, Text, View } from "react-native";
+import { CameraView, useCameraPermissions, useMicrophonePermissions } from "expo-camera";
+import { jsx, jsxs } from "react/jsx-runtime";
+var SCAN_TIMEOUT_MS = 3e4;
+var MAX_RECORD_MS = 6e4;
+function CameraTaskHost() {
+  const [task, setTask] = useState(cameraTasks.current());
+  const [camPermission, requestCamPermission] = useCameraPermissions();
+  const [micPermission, requestMicPermission] = useMicrophonePermissions();
+  const cameraRef = useRef(null);
+  const settling = useRef(false);
+  useEffect(() => {
+    cameraTasks.setHostMounted(true);
+    return () => cameraTasks.setHostMounted(false);
+  }, []);
+  useEffect(() => cameraTasks.subscribe(() => {
+    settling.current = false;
+    setTask(cameraTasks.current());
+  }), []);
+  useEffect(() => {
+    if (!task) return;
+    let cancelled = false;
+    void (async () => {
+      const cam = camPermission?.granted ? camPermission : await requestCamPermission();
+      if (cancelled) return;
+      if (!cam?.granted) {
+        cameraTasks.fail(cameraError(
+          "PERMISSION_DENIED",
+          "Camera permission was not granted. Enable it for this app in Settings > Privacy > Camera."
+        ));
+        return;
+      }
+      if (task.kind === "record" && task.opts.withAudio) {
+        const mic = micPermission?.granted ? micPermission : await requestMicPermission();
+        if (cancelled) return;
+        if (!mic?.granted) {
+          cameraTasks.fail(cameraError(
+            "PERMISSION_DENIED",
+            "Microphone permission was not granted, so a video with sound cannot be recorded."
+          ));
+        }
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [task]);
+  useEffect(() => {
+    if (task?.kind !== "scan") return;
+    const ms = task.opts.timeoutMs ?? SCAN_TIMEOUT_MS;
+    const t = setTimeout(() => {
+      cameraTasks.fail(cameraError("TIMEOUT", `No barcode was found within ${Math.round(ms / 1e3)}s.`));
+    }, ms);
+    return () => clearTimeout(t);
+  }, [task]);
+  useEffect(() => {
+    if (task?.kind !== "record" || !camPermission?.granted) return;
+    let cancelled = false;
+    const maxMs = Math.min(task.opts.maxDurationMs ?? 15e3, MAX_RECORD_MS);
+    const startedAt = Date.now();
+    void (async () => {
+      await new Promise((r) => setTimeout(r, 50));
+      if (cancelled || !cameraRef.current) return;
+      try {
+        const video = await cameraRef.current.recordAsync({ maxDuration: Math.ceil(maxMs / 1e3) });
+        if (cancelled) return;
+        if (!video?.uri) {
+          cameraTasks.fail(cameraError("INTERNAL", "Recording finished but produced no file."));
+          return;
+        }
+        cameraTasks.complete({ uri: video.uri, durationMs: Date.now() - startedAt });
+      } catch (err) {
+        if (!cancelled) cameraTasks.fail(cameraError("INTERNAL", err?.message || "Recording failed."));
+      }
+    })();
+    return () => {
+      cancelled = true;
+      try {
+        cameraRef.current?.stopRecording();
+      } catch {
+      }
+    };
+  }, [task, camPermission?.granted]);
+  if (!task || !camPermission?.granted) return null;
+  const isScan = task.kind === "scan";
+  return /* @__PURE__ */ jsxs(View, { style: styles.overlay, children: [
+    /* @__PURE__ */ jsx(
+      CameraView,
+      {
+        ref: cameraRef,
+        style: StyleSheet.absoluteFill,
+        facing: "back",
+        mode: isScan ? "picture" : "video",
+        barcodeScannerSettings: isScan && task.opts.formats?.length ? { barcodeTypes: task.opts.formats } : void 0,
+        onBarcodeScanned: isScan ? ({ data, type }) => {
+          if (settling.current) return;
+          settling.current = true;
+          cameraTasks.complete({ data, format: type });
+        } : void 0
+      }
+    ),
+    /* @__PURE__ */ jsxs(View, { style: styles.hud, pointerEvents: "box-none", children: [
+      /* @__PURE__ */ jsx(Text, { style: styles.hint, children: isScan ? "Point the camera at the code" : "Recording\u2026" }),
+      /* @__PURE__ */ jsx(Pressable, { style: styles.cancel, onPress: () => cameraTasks.cancel(), accessibilityRole: "button", children: /* @__PURE__ */ jsx(Text, { style: styles.cancelText, children: "Cancel" }) })
+    ] })
+  ] });
+}
+var styles = StyleSheet.create({
+  overlay: { ...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/device-state/replay.ts
+var DOMAINS = [
+  "spatial",
+  "visual",
+  "activity",
+  "deviceContext",
+  "connectivity",
+  "capability",
+  "environment",
+  "interaction"
+];
+function unknownSnapshot(domain) {
+  const quality = { freshness: { state: "unknown", observedAt: null, ageMs: null }, confidence: { level: "unknown" } };
+  switch (domain) {
+    case "spatial":
+      return { ...{ quality }, position: null, movement: { speedMps: null, bearingDeg: null, distanceRecentM: null, state: "unknown" }, orientation: { headingDeg: null }, recentPath: [] };
+    case "visual":
+      return { quality, camera: { available: false, active: false, facing: "unknown" }, latest: null, recentTimeline: { windowMs: 0, frames: [] } };
+    case "activity":
+      return { quality, human: { state: "unknown", since: null, confidence: { level: "unknown" } }, devicePose: { placement: "unknown", orientation: "unknown", confidence: { level: "unknown" } }, recentTransitions: [] };
+    default:
+      return { quality };
+  }
+}
+function refusal(domain, code, message) {
+  const err = new Error(message || `deviceState.${domain}: refused during recording (${code}).`);
+  err.code = code;
+  err.domain = domain;
+  return err;
+}
+function createReplayDeviceState(fixture) {
+  const samples = [...fixture.samples || []].sort((a, b) => a.t - b.t);
+  const duration = samples.length ? samples[samples.length - 1].t : 0;
+  const refusals = new Map((fixture.refusals || []).map((r) => [r.domain, r]));
+  const openSessions = /* @__PURE__ */ new Set();
+  let cursor = 0;
+  const spatialDetector = new SpatialEventDetector();
+  const spatialListeners = listenerSet();
+  const moveTo = (target) => {
+    const next = Math.min(duration, Math.max(0, target));
+    if (!openSessions.has("spatial")) return cursor = next;
+    if (next < cursor) {
+      cursor = next;
+      spatialDetector.reset(void 0, turnOnRecordAt());
+      return cursor;
+    }
+    const from = cursor;
+    for (const s of samples) {
+      if (s.t <= from || !s.spatial) continue;
+      if (s.t > next) break;
+      cursor = s.t;
+      for (const event of spatialDetector.push(s.spatial, s.t)) spatialListeners.emit(event);
+    }
+    return cursor = next;
+  };
+  const clock = {
+    now: () => cursor,
+    advance: (ms) => moveTo(cursor + ms),
+    seek: (ms) => moveTo(ms),
+    end: () => moveTo(duration),
+    durationMs: () => duration
+  };
+  const sampleAt = () => {
+    let found = null;
+    for (const s of samples) {
+      if (s.t > cursor) break;
+      found = s;
+    }
+    return found;
+  };
+  const turnOnRecordAt = () => sampleAt()?.spatial?.changes?.timestamp ?? null;
+  const domainFor = (name) => ({
+    async getSnapshot() {
+      const s = sampleAt();
+      const recorded = s ? s[name] : void 0;
+      return recorded ?? unknownSnapshot(name);
+    },
+    async start(options) {
+      const r = refusals.get(name);
+      if (r) throw refusal(name, r.code, r.message);
+      if (name === "spatial" && !openSessions.has(name)) {
+        spatialDetector.reset(spatialEventProfile(options?.intent), turnOnRecordAt());
+      }
+      openSessions.add(name);
+      return { id: `replay_${name}`, intent: "replay", startedAt: 0 };
+    },
+    async stop() {
+      openSessions.delete(name);
+      if (name === "spatial") spatialDetector.reset();
+    },
+    subscribe(listener) {
+      if (name === "spatial") return spatialListeners.add(listener);
+      throw refusal(name, "UNSUPPORTED", `deviceState.${name}.subscribe is not replayable \u2014 advance the clock and read.`);
+    }
+  });
+  const deviceState = {};
+  for (const d of DOMAINS) deviceState[d] = domainFor(d);
+  return { deviceState, clock, started: () => [...openSessions] };
+}
+function parseWalkJsonl(text) {
+  const lines = text.split("\n").map((l) => l.trim()).filter(Boolean);
+  if (!lines.length) throw new Error("Empty recording \u2014 no header line.");
+  const first = JSON.parse(lines[0]);
+  const header = first.header ?? first;
+  const refusals = first.refusals ?? [];
+  const samples = [];
+  for (const line of lines.slice(1)) {
+    const rec = JSON.parse(line);
+    if (rec.refusal) {
+      refusals.push(rec.refusal);
+      continue;
+    }
+    if (typeof rec.t === "number") samples.push(rec);
+  }
+  return { header, refusals, samples };
+}
+
+// src/index.ts
+function setupExpoProviders(opts) {
+  setHapticsProvider(expoHaptics);
+  if (opts?.deviceProvider) setPluginNativeProvider(opts.deviceProvider);
+  setBundleStorage(new ExpoBundleStorage({ indexKey: opts?.bundleIndexKey }));
+  setClipboardProvider({
+    setString: (text) => ExpoClipboard.setStringAsync(text).then(() => {
+    })
+  });
+  registerBundleModules({
+    "expo-web-browser": ExpoWebBrowser,
+    "expo-linking": ExpoLinking,
+    ...opts?.bundleModules || {}
+  });
+  setAcsCacheStorage({
+    getItem: (k) => AsyncStorage3.getItem(k),
+    setItem: (k, v) => AsyncStorage3.setItem(k, v)
+  });
+  return { attachmentCache: new ExpoAttachmentCache({ indexKey: opts?.attachmentIndexKey }) };
+}
+
+export {
+  expoHaptics,
+  ExpoBundleStorage,
+  ExpoAttachmentCache,
+  visualEngine,
+  createDeviceState,
+  IMPLEMENTED_DOMAINS,
+  CameraTaskHost,
+  createReplayDeviceState,
+  parseWalkJsonl,
+  setupExpoProviders
+};
+//# sourceMappingURL=chunk-C7M5WAHA.mjs.map