@ateam-ai-mobile/expo 0.1.4 → 0.1.7

package/dist/chunk-4XYXJYN5.mjs

@@ -0,0 +1,1513 @@
+import {
+  cameraError,
+  cameraTasks
+} from "./chunk-6LXF3JVX.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/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.
+    subscribe(listener) {
+      const subs = [
+        ExpoBattery.addBatteryLevelListener(() => listener({ type: "batteryLevelChanged" })),
+        ExpoBattery.addBatteryStateListener(() => listener({ type: "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({ type: "appStateChanged", appState: mapState(next) });
+      });
+      return { unsubscribe: () => sub2.remove() };
+    }
+  };
+}
+
+// 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/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 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 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);
+  };
+  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: nonNegative(fix.accuracy),
+            timestamp: fix.timestamp ?? Date.now()
+          };
+          speedMps = nonNegative(fix.speed);
+          courseDeg = nonNegative(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: 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);
+      });
+      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");
+    }
+  };
+}
+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"
+        },
+        // 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();
+      return { id: s.id, intent: s.intent, startedAt: s.startedAt };
+    },
+    async stop() {
+      visualEngine.stopSession();
+      visualEngine.setContextProvider(null);
+      stopHeading();
+    },
+    /**
+     * 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;
+    },
+    subscribe(listener) {
+      const off = visualEngine.subscribe(() => {
+        listener({ type: "visualStateChanged" });
+      });
+      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 clock = {
+    now: () => cursor,
+    advance: (ms) => cursor = Math.min(duration, Math.max(0, cursor + ms)),
+    seek: (ms) => cursor = Math.min(duration, Math.max(0, ms)),
+    end: () => cursor = duration,
+    durationMs: () => duration
+  };
+  const sampleAt = () => {
+    let found = null;
+    for (const s of samples) {
+      if (s.t > cursor) break;
+      found = s;
+    }
+    return found;
+  };
+  const domainFor = (name) => ({
+    async getSnapshot() {
+      const s = sampleAt();
+      const recorded = s ? s[name] : void 0;
+      return recorded ?? unknownSnapshot(name);
+    },
+    async start() {
+      const r = refusals.get(name);
+      if (r) throw refusal(name, r.code, r.message);
+      openSessions.add(name);
+      return { id: `replay_${name}`, intent: "replay", startedAt: 0 };
+    },
+    async stop() {
+      openSessions.delete(name);
+    },
+    subscribe() {
+      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-4XYXJYN5.mjs.map