@ateam-ai-mobile/expo 0.1.4 → 0.1.7

package/dist/device/createDeviceProvider.js

@@ -0,0 +1,967 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/device-bridge/cookies.ts
+var cookies_exports = {};
+__export(cookies_exports, {
+  clearAll: () => clearAll,
+  get: () => get,
+  set: () => set
+});
+async function get(url, includeHttpOnly = true) {
+  const raw = await import_cookies.default.get(url, includeHttpOnly);
+  const out = [];
+  for (const [name, c] of Object.entries(raw || {})) {
+    if (!c || typeof c !== "object") continue;
+    const value = typeof c.value === "string" ? c.value : String(c.value ?? "");
+    const cookie = { name, value };
+    if (c.domain) cookie.domain = String(c.domain);
+    if (c.path) cookie.path = String(c.path);
+    if (c.expires) {
+      const t = Date.parse(c.expires);
+      if (!Number.isNaN(t)) cookie.expires = Math.floor(t / 1e3);
+    }
+    if (typeof c.httpOnly === "boolean") cookie.httpOnly = c.httpOnly;
+    if (typeof c.secure === "boolean") cookie.secure = c.secure;
+    if (c.sameSite === "Lax" || c.sameSite === "Strict" || c.sameSite === "None") {
+      cookie.sameSite = c.sameSite;
+    }
+    out.push(cookie);
+  }
+  return out;
+}
+async function clearAll() {
+  try {
+    await import_cookies.default.clearAll(true);
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: String(e?.message || e) };
+  }
+}
+async function set(url, cookie) {
+  try {
+    await import_cookies.default.set(url, {
+      name: cookie.name,
+      value: cookie.value,
+      domain: cookie.domain,
+      path: cookie.path || "/",
+      httpOnly: cookie.httpOnly,
+      secure: cookie.secure
+    }, true);
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: String(e?.message || e) };
+  }
+}
+var import_cookies;
+var init_cookies = __esm({
+  "src/device-bridge/cookies.ts"() {
+    "use strict";
+    import_cookies = __toESM(require("@react-native-cookies/cookies"));
+  }
+});
+
+// src/device-bridge/nfc.ts
+var nfc_exports = {};
+__export(nfc_exports, {
+  isEnabled: () => isEnabled,
+  isSupported: () => isSupported2,
+  readOnce: () => readOnce
+});
+async function ensureInit() {
+  if (_initialized) return true;
+  try {
+    const supported = await import_react_native_nfc_manager.default.isSupported();
+    if (!supported) return false;
+    await import_react_native_nfc_manager.default.start();
+    _initialized = true;
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+async function isSupported2() {
+  try {
+    return await import_react_native_nfc_manager.default.isSupported();
+  } catch {
+    return false;
+  }
+}
+async function isEnabled() {
+  try {
+    return await import_react_native_nfc_manager.default.isEnabled();
+  } catch {
+    return false;
+  }
+}
+async function readOnce(timeoutMs = 3e4) {
+  const ready = await ensureInit();
+  if (!ready) return { ok: false, error: "nfc_unsupported" };
+  try {
+    const tag = await Promise.race([
+      import_react_native_nfc_manager.default.requestTechnology(import_react_native_nfc_manager.NfcTech.Ndef).then(() => import_react_native_nfc_manager.default.getTag()),
+      new Promise((resolve) => setTimeout(() => resolve(null), timeoutMs))
+    ]);
+    if (!tag) {
+      try {
+        await import_react_native_nfc_manager.default.cancelTechnologyRequest();
+      } catch {
+      }
+      return { ok: false, error: "timeout" };
+    }
+    const records = [];
+    if (tag.ndefMessage) {
+      for (const r of tag.ndefMessage) {
+        try {
+          const type = String.fromCharCode(...r.type || []);
+          const payload = import_react_native_nfc_manager.Ndef.text.decodePayload(r.payload || []);
+          records.push({ type, payload: String(payload) });
+        } catch {
+        }
+      }
+    }
+    const tagId = tag.id ? Array.from(tag.id).map((b) => b.toString(16).padStart(2, "0")).join("") : void 0;
+    return { ok: true, tagId, records };
+  } catch (e) {
+    return { ok: false, error: String(e?.message || e) };
+  } finally {
+    try {
+      await import_react_native_nfc_manager.default.cancelTechnologyRequest();
+    } catch {
+    }
+  }
+}
+var import_react_native_nfc_manager, _initialized;
+var init_nfc = __esm({
+  "src/device-bridge/nfc.ts"() {
+    "use strict";
+    import_react_native_nfc_manager = __toESM(require("react-native-nfc-manager"));
+    _initialized = false;
+  }
+});
+
+// src/device/createDeviceProvider.ts
+var createDeviceProvider_exports = {};
+__export(createDeviceProvider_exports, {
+  clearAllPluginData: () => clearAllPluginData,
+  createDeviceProvider: () => createDeviceProvider
+});
+module.exports = __toCommonJS(createDeviceProvider_exports);
+var Haptics = __toESM(require("expo-haptics"));
+var ExpoLocation2 = __toESM(require("expo-location"));
+var ImagePicker = __toESM(require("expo-image-picker"));
+var Notifications = __toESM(require("expo-notifications"));
+var DocumentPicker = __toESM(require("expo-document-picker"));
+var FS = __toESM(require("expo-file-system"));
+var SQLite = __toESM(require("expo-sqlite"));
+
+// src/camera/cameraTasks.ts
+function cameraError(code, message) {
+  const err = new Error(message);
+  err.code = code;
+  return err;
+}
+var CameraTaskBroker = class {
+  constructor() {
+    this.task = null;
+    this.listeners = /* @__PURE__ */ new Set();
+    /** Set by the host while a camera is mounted and ready. */
+    this.hostMounted = false;
+  }
+  current() {
+    return this.task;
+  }
+  subscribe(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+  /**
+   * Declare that a `CameraTaskHost` exists.
+   *
+   * Without it nothing will ever settle the promise, so a request must fail
+   * IMMEDIATELY and say why. The alternative is a plugin awaiting forever,
+   * which is the worst failure of the set: no error, no timeout, no camera,
+   * and a conversation that simply stops.
+   */
+  setHostMounted(mounted) {
+    this.hostMounted = mounted;
+    if (!mounted) this.fail(cameraError("UNAVAILABLE", "The camera surface was dismissed before the task completed."));
+    this.notify();
+  }
+  isHostMounted() {
+    return this.hostMounted;
+  }
+  /** Enqueue and hand back the promise the plugin awaits. */
+  run(kind, opts) {
+    if (!this.hostMounted) {
+      return Promise.reject(cameraError(
+        "UNAVAILABLE",
+        "No camera surface is mounted in this app, so the camera cannot be shown. The host must render <CameraTaskHost /> once, near the app root."
+      ));
+    }
+    if (this.task) {
+      return Promise.reject(cameraError(
+        "BUSY",
+        `The camera is already in use (${this.task.kind}). Only one camera task can run at a time.`
+      ));
+    }
+    return new Promise((resolve, reject) => {
+      this.task = { kind, opts, resolve, reject };
+      this.notify();
+    });
+  }
+  /** Settle the running task successfully and clear it. */
+  complete(value) {
+    const t = this.task;
+    if (!t) return;
+    this.task = null;
+    this.notify();
+    t.resolve(value);
+  }
+  /** Settle the running task with a failure and clear it. */
+  fail(err) {
+    const t = this.task;
+    if (!t) return;
+    this.task = null;
+    this.notify();
+    t.reject(err);
+  }
+  /**
+   * The user backed out.
+   *
+   * A distinct code, because "the user chose not to" is not a malfunction and
+   * a guide should say something different about it than about a broken lens.
+   */
+  cancel() {
+    this.fail(cameraError("CANCELLED", "Cancelled \u2014 the camera was dismissed before anything was captured."));
+  }
+  notify() {
+    for (const fn of this.listeners) {
+      try {
+        fn();
+      } catch {
+      }
+    }
+  }
+};
+var cameraTasks = new CameraTaskBroker();
+
+// src/device/createDeviceProvider.ts
+var import_async_storage3 = __toESM(require("@react-native-async-storage/async-storage"));
+
+// src/vision/index.ts
+var import_expo_modules_core = require("expo-modules-core");
+var import_expo = require("expo");
+var CameraPreview = (() => {
+  try {
+    return (0, import_expo.requireNativeView)("AdaVision");
+  } catch {
+    return null;
+  }
+})();
+var native = (0, import_expo_modules_core.requireOptionalNativeModule)("AdaVision");
+function isSupported() {
+  try {
+    return native?.isSupported() ?? false;
+  } catch {
+    return false;
+  }
+}
+function qualityById(id) {
+  return native?.qualityById?.(id) ?? null;
+}
+async function readText(id, languages) {
+  if (!native) throw new Error("ada-vision native module not present in this build");
+  return native.readText(id, languages ?? null);
+}
+async function describe(id, maxLabels = 5) {
+  if (!native) throw new Error("ada-vision native module not present in this build");
+  return native.describe(id, maxLabels);
+}
+async function detectObjects(id, maxItems = 10, minConfidence = 0.25) {
+  if (!native) throw new Error("ada-vision native module not present in this build");
+  return native.detectObjects(id, maxItems, minConfidence);
+}
+
+// src/device-bridge/actions/messaging.ts
+var SMS = __toESM(require("expo-sms"));
+
+// src/device-bridge/actions/calendar-actions.ts
+var ExpoCalendar = __toESM(require("expo-calendar"));
+
+// src/device-bridge/actions/navigation.ts
+var Linking = __toESM(require("expo-linking"));
+var import_react_native = require("react-native");
+
+// src/device-bridge/collectors/health.ts
+var import_react_native2 = require("react-native");
+
+// src/device-bridge/background.ts
+var TaskManager = __toESM(require("expo-task-manager"));
+var BackgroundFetch = __toESM(require("expo-background-fetch"));
+
+// src/device-bridge/collectors/calendar.ts
+var ExpoCalendar2 = __toESM(require("expo-calendar"));
+
+// src/device-bridge/collectors/contacts.ts
+var ExpoContacts = __toESM(require("expo-contacts"));
+var import_async_storage = __toESM(require("@react-native-async-storage/async-storage"));
+
+// src/device-bridge/collectors/location.ts
+var ExpoLocation = __toESM(require("expo-location"));
+
+// src/device-bridge/collectors/battery.ts
+var ExpoBattery = __toESM(require("expo-battery"));
+
+// src/device-bridge/collectors/connectivity.ts
+var ExpoNetwork = __toESM(require("expo-network"));
+
+// src/device-bridge/collectors/notifications.ts
+var ExpoNotifications = __toESM(require("expo-notifications"));
+
+// src/device-bridge/collectors/appEngagement.ts
+var import_react_native3 = require("react-native");
+var import_async_storage2 = __toESM(require("@react-native-async-storage/async-storage"));
+
+// src/device-bridge/collectors/camera.ts
+var import_expo_camera = require("expo-camera");
+
+// src/device-bridge/biometrics.ts
+var biometrics_exports = {};
+__export(biometrics_exports, {
+  authenticate: () => authenticate,
+  capabilities: () => capabilities
+});
+var LocalAuthentication = __toESM(require("expo-local-authentication"));
+async function capabilities() {
+  const [hasHardware, isEnrolled, types] = await Promise.all([
+    LocalAuthentication.hasHardwareAsync(),
+    LocalAuthentication.isEnrolledAsync(),
+    LocalAuthentication.supportedAuthenticationTypesAsync()
+  ]);
+  const supportedTypes = types.map((t) => {
+    if (t === LocalAuthentication.AuthenticationType.FINGERPRINT) return "fingerprint";
+    if (t === LocalAuthentication.AuthenticationType.FACIAL_RECOGNITION) return "face";
+    if (t === LocalAuthentication.AuthenticationType.IRIS) return "iris";
+    return "none";
+  }).filter((t) => t !== "none");
+  return { hasHardware, isEnrolled, supportedTypes };
+}
+async function authenticate(opts) {
+  try {
+    const res = await LocalAuthentication.authenticateAsync({
+      promptMessage: opts.reason,
+      cancelLabel: opts.cancelLabel,
+      disableDeviceFallback: opts.fallbackToPasscode === false
+    });
+    if (res.success) return { success: true };
+    return { success: false, error: res.error || "unknown" };
+  } catch (e) {
+    return { success: false, error: String(e?.message || e) };
+  }
+}
+
+// src/device-bridge/sharing.ts
+var sharing_exports = {};
+__export(sharing_exports, {
+  isAvailable: () => isAvailable,
+  shareFile: () => shareFile
+});
+var Sharing = __toESM(require("expo-sharing"));
+async function shareFile(fileUri, opts = {}) {
+  try {
+    const available = await Sharing.isAvailableAsync();
+    if (!available) return { ok: false, error: "sharing_unavailable" };
+    await Sharing.shareAsync(fileUri, opts);
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: String(e?.message || e) };
+  }
+}
+async function isAvailable() {
+  return Sharing.isAvailableAsync();
+}
+
+// src/device-bridge/scanner.ts
+var scanner_exports = {};
+__export(scanner_exports, {
+  CameraView: () => import_expo_camera2.CameraView,
+  normalizeResult: () => normalizeResult,
+  requestPermissions: () => requestPermissions,
+  useCameraPermissions: () => import_expo_camera2.useCameraPermissions
+});
+var import_expo_camera2 = require("expo-camera");
+async function requestPermissions() {
+  const { Camera: Camera2 } = await import("expo-camera");
+  const { status } = await Camera2.requestCameraPermissionsAsync();
+  return { granted: status === "granted", status };
+}
+function normalizeResult(r) {
+  return { type: r.type, data: r.data };
+}
+
+// src/device/createDeviceProvider.ts
+function getDeviceCookies() {
+  try {
+    return init_cookies(), __toCommonJS(cookies_exports);
+  } catch {
+    return null;
+  }
+}
+function getDeviceNfc() {
+  try {
+    return init_nfc(), __toCommonJS(nfc_exports);
+  } catch {
+    return null;
+  }
+}
+var CapabilityUnavailableError = class extends Error {
+  constructor(capability, reason) {
+    super(reason || `${capability} is not yet implemented. Coming in Phase 2.`);
+    this.code = "UNAVAILABLE";
+    this.name = "CapabilityUnavailableError";
+  }
+};
+function stubApi(capability) {
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (typeof prop === "string") {
+        return () => {
+          throw new CapabilityUnavailableError(capability);
+        };
+      }
+    }
+  });
+}
+function createLocationAPI() {
+  const ensurePermission = async () => {
+    const existing = await ExpoLocation2.getForegroundPermissionsAsync();
+    if (existing.status === "granted") return;
+    const asked = await ExpoLocation2.requestForegroundPermissionsAsync();
+    if (asked.status !== "granted") {
+      throw new Error(
+        "Location permission was not granted. Enable it for this app in Settings > Privacy > Location Services."
+      );
+    }
+  };
+  return {
+    async getCurrent(opts) {
+      await ensurePermission();
+      const fix = await ExpoLocation2.getCurrentPositionAsync({
+        accuracy: opts?.accuracy === "high" ? ExpoLocation2.Accuracy.High : ExpoLocation2.Accuracy.Balanced
+      });
+      return {
+        latitude: fix.coords.latitude,
+        longitude: fix.coords.longitude,
+        altitude: fix.coords.altitude ?? void 0
+      };
+    },
+    watchPosition(cb) {
+      let subscription = null;
+      let cancelled = false;
+      void (async () => {
+        try {
+          await ensurePermission();
+          if (cancelled) return;
+          subscription = await ExpoLocation2.watchPositionAsync(
+            { accuracy: ExpoLocation2.Accuracy.Balanced },
+            (fix) => cb({ latitude: fix.coords.latitude, longitude: fix.coords.longitude })
+          );
+          if (cancelled) {
+            subscription?.remove();
+            subscription = null;
+          }
+        } catch (err) {
+          console.warn("[location] watchPosition failed:", err?.message || String(err));
+        }
+      })();
+      return () => {
+        cancelled = true;
+        subscription?.remove();
+        subscription = null;
+      };
+    }
+  };
+}
+function createCameraAPI() {
+  const ensurePermission = async () => {
+    const existing = await ImagePicker.getCameraPermissionsAsync();
+    if (existing.granted) return;
+    const asked = await ImagePicker.requestCameraPermissionsAsync();
+    if (!asked.granted) {
+      throw new Error(
+        "Camera permission was not granted. Enable it for this app in Settings > Privacy > Camera."
+      );
+    }
+  };
+  return {
+    async takePhoto(opts) {
+      await ensurePermission();
+      const res = await ImagePicker.launchCameraAsync({
+        quality: opts?.quality ?? 0.7,
+        cameraType: opts?.facing === "front" ? ImagePicker.CameraType.front : ImagePicker.CameraType.back
+      });
+      if (res.canceled || !res.assets?.[0]) {
+        throw new Error("No photo taken \u2014 the camera was dismissed.");
+      }
+      const a = res.assets[0];
+      return { uri: a.uri, width: a.width, height: a.height };
+    },
+    async scanBarcode(opts) {
+      throw new CapabilityUnavailableError(
+        "camera.scanBarcode",
+        "Use native.scanner.scanOnce() instead \u2014 scanning needs a mounted camera, which this call cannot provide. Same arguments, and it returns { data, format }." + (opts?.formats?.length ? " Pass your formats through to scanOnce." : "")
+      );
+    },
+    async recordVideo(opts) {
+      return cameraTasks.run("record", {
+        maxDurationMs: opts?.maxDurationMs,
+        withAudio: opts?.withAudio ?? false
+      });
+    },
+    async pickImage(opts) {
+      const existing = await ImagePicker.getMediaLibraryPermissionsAsync();
+      if (!existing.granted) {
+        const asked = await ImagePicker.requestMediaLibraryPermissionsAsync();
+        if (!asked.granted) {
+          throw new Error(
+            "Photo library permission was not granted. Enable it for this app in Settings > Privacy > Photos."
+          );
+        }
+      }
+      const res = await ImagePicker.launchImageLibraryAsync({
+        allowsMultipleSelection: !!opts?.multiple
+      });
+      if (res.canceled) return [];
+      return (res.assets || []).map((a) => ({ uri: a.uri }));
+    }
+  };
+}
+var _pluginDbs = /* @__PURE__ */ new Map();
+function openPluginDb(file) {
+  const existing = _pluginDbs.get(file);
+  if (existing) return existing;
+  const opened = SQLite.openDatabaseAsync(file);
+  _pluginDbs.set(file, opened);
+  return opened;
+}
+function sqlLeadingKeyword(sql) {
+  let s = String(sql);
+  for (; ; ) {
+    const before = s;
+    s = s.replace(/^\s+/, "");
+    if (s.startsWith("--")) {
+      const nl = s.indexOf("\n");
+      s = nl === -1 ? "" : s.slice(nl + 1);
+    } else if (s.startsWith("/*")) {
+      const end = s.indexOf("*/");
+      s = end === -1 ? "" : s.slice(end + 2);
+    }
+    if (s === before) break;
+  }
+  const m = s.match(/^[A-Za-z]+/);
+  return m ? m[0].toUpperCase() : "";
+}
+function createStorageAPI(pluginId) {
+  const ns = encodeURIComponent(pluginId);
+  const key = (k) => `@plugin:${ns}:${k}`;
+  const dbFile = `plugin-storage-${ns}.db`;
+  return {
+    get: (k) => import_async_storage3.default.getItem(key(k)),
+    set: (k, v) => import_async_storage3.default.setItem(key(k), v),
+    delete: (k) => import_async_storage3.default.removeItem(key(k)),
+    db: {
+      async execute(sql, params) {
+        const verb = sqlLeadingKeyword(sql);
+        if (verb === "ATTACH" || verb === "DETACH" || verb === "VACUUM") {
+          throw new CapabilityUnavailableError(
+            "storage.db",
+            `SQL '${verb}' is not permitted: a plugin's storage is confined to its own database and cannot reach another file.`
+          );
+        }
+        const db = await openPluginDb(dbFile);
+        const returnsRows = verb === "SELECT" || verb === "PRAGMA" || verb === "WITH";
+        if (returnsRows) {
+          const rows = await db.getAllAsync(sql, params ?? []);
+          return { rows, changes: 0 };
+        }
+        const res = await db.runAsync(sql, params ?? []);
+        return { rows: [], changes: res.changes ?? 0 };
+      }
+    }
+  };
+}
+async function clearAllPluginData() {
+  try {
+    const keys = await import_async_storage3.default.getAllKeys();
+    const mine = keys.filter((k) => k.startsWith("@plugin:"));
+    if (mine.length) await import_async_storage3.default.multiRemove(mine);
+  } catch (e) {
+    console.warn("[adas] clearAllPluginData: KV clear failed:", e?.message || e);
+  }
+  try {
+    for (const [, p] of _pluginDbs) {
+      try {
+        const db = await p;
+        await db.closeAsync?.();
+      } catch {
+      }
+    }
+    _pluginDbs.clear();
+    const sqliteDir = new FS.Directory(FS.Paths.document, "SQLite");
+    if (sqliteDir.exists) {
+      for (const entry of sqliteDir.list()) {
+        if (/^plugin-storage-.*\.db$/.test(String(entry.name ?? ""))) {
+          try {
+            entry.delete();
+          } catch {
+          }
+        }
+      }
+    }
+  } catch (e) {
+    console.warn("[adas] clearAllPluginData: SQLite clear failed:", e?.message || e);
+  }
+  try {
+    const dir = new FS.Directory(FS.Paths.document, "plugin-files");
+    if (dir.exists) dir.delete();
+  } catch (e) {
+    console.warn("[adas] clearAllPluginData: file sandbox clear failed:", e?.message || e);
+  }
+}
+function createNotificationsAPI() {
+  return {
+    async schedule({ title, body, trigger }) {
+      const perm = await Notifications.getPermissionsAsync();
+      if (!perm.granted) {
+        const asked = await Notifications.requestPermissionsAsync();
+        if (!asked.granted) {
+          throw new Error(
+            "Notification permission was not granted. Enable it for this app in Settings > Notifications."
+          );
+        }
+      }
+      const when = typeof trigger?.seconds === "number" ? { type: "timeInterval", seconds: trigger.seconds, repeats: false } : trigger?.date ? { type: "date", date: new Date(trigger.date) } : null;
+      if (!when) {
+        throw new Error("schedule() needs trigger.seconds or trigger.date.");
+      }
+      return Notifications.scheduleNotificationAsync({
+        content: { title, body },
+        trigger: when
+      });
+    },
+    cancel: (id) => Notifications.cancelScheduledNotificationAsync(id),
+    onReceived(cb) {
+      const sub = Notifications.addNotificationReceivedListener((n) => {
+        cb({
+          id: n.request.identifier,
+          title: n.request.content.title || "",
+          body: n.request.content.body || "",
+          data: n.request.content.data
+        });
+      });
+      return () => sub.remove();
+    }
+  };
+}
+function createFileSystemAPI(pluginId) {
+  let _root = null;
+  const rootDir = () => _root ?? (_root = new FS.Directory(FS.Paths.document, "plugin-files", pluginId));
+  const resolve = (p) => {
+    const root = rootDir();
+    const file = new FS.File(root, p);
+    if (!file.uri.startsWith(root.uri)) {
+      throw new CapabilityUnavailableError(
+        "fileSystem",
+        `Path escapes the plugin's storage area: ${p}. Plugin files live under plugin-files/ and paths cannot traverse out of it.`
+      );
+    }
+    return file;
+  };
+  return {
+    async readFile(path) {
+      const file = resolve(path);
+      if (!file.exists) {
+        throw new CapabilityUnavailableError(
+          "fileSystem.readFile",
+          `No such file: ${path}. Nothing was read.`
+        );
+      }
+      return file.text();
+    },
+    async writeFile(path, content) {
+      const file = resolve(path);
+      const parent = file.parentDirectory;
+      if (!parent.exists) parent.create({ intermediates: true });
+      if (!file.exists) file.create();
+      file.write(content);
+    },
+    async pickDocument(opts) {
+      const res = await DocumentPicker.getDocumentAsync({
+        type: opts?.types?.length ? opts.types : "*/*",
+        copyToCacheDirectory: true
+      });
+      if (res.canceled || !res.assets?.[0]) {
+        throw new Error("No document chosen \u2014 the picker was dismissed.");
+      }
+      const a = res.assets[0];
+      return { uri: a.uri, name: a.name, size: a.size ?? 0 };
+    }
+  };
+}
+function createHapticsAPI() {
+  return {
+    impact(style) {
+      const map = {
+        light: Haptics.ImpactFeedbackStyle.Light,
+        medium: Haptics.ImpactFeedbackStyle.Medium,
+        heavy: Haptics.ImpactFeedbackStyle.Heavy
+      };
+      Haptics.impactAsync(map[style]);
+    },
+    notification(type) {
+      const map = {
+        success: Haptics.NotificationFeedbackType.Success,
+        warning: Haptics.NotificationFeedbackType.Warning,
+        error: Haptics.NotificationFeedbackType.Error
+      };
+      Haptics.notificationAsync(map[type]);
+    },
+    // Shorthand for notification('error'). Plugins call this; it was never
+    // implemented, and optional chaining meant the failure the user was meant
+    // to FEEL simply did not happen.
+    error() {
+      Haptics.notificationAsync(Haptics.NotificationFeedbackType.Error);
+    },
+    selection() {
+      Haptics.selectionAsync();
+    }
+  };
+}
+function createConnectivityAPI(reachabilityUrl) {
+  let online = true;
+  const listeners = /* @__PURE__ */ new Set();
+  let interval = null;
+  const checkOnline = async () => {
+    if (!reachabilityUrl) return true;
+    try {
+      const res = await fetch(reachabilityUrl, {
+        method: "HEAD",
+        signal: AbortSignal.timeout(5e3)
+      });
+      return res.ok;
+    } catch {
+      return false;
+    }
+  };
+  const startPolling = () => {
+    if (!reachabilityUrl) return;
+    if (interval) return;
+    interval = setInterval(async () => {
+      const newState = await checkOnline();
+      if (newState !== online) {
+        online = newState;
+        listeners.forEach((cb) => cb(online));
+      }
+    }, 3e4);
+  };
+  return {
+    isOnline() {
+      return online;
+    },
+    onChange(cb) {
+      listeners.add(cb);
+      startPolling();
+      return () => {
+        listeners.delete(cb);
+        if (listeners.size === 0 && interval) {
+          clearInterval(interval);
+          interval = null;
+        }
+      };
+    }
+  };
+}
+function createCookiesAPI() {
+  return {
+    async get(url) {
+      const mod = getDeviceCookies();
+      if (!mod) throw new CapabilityUnavailableError("cookies (native module not available \u2014 use a dev build)");
+      const list = await mod.get(url, true);
+      return list;
+    },
+    async clear(_url) {
+      const mod = getDeviceCookies();
+      if (!mod) throw new CapabilityUnavailableError("cookies (native module not available \u2014 use a dev build)");
+      const r = await mod.clearAll();
+      return { ok: r.ok };
+    }
+  };
+}
+function createBiometricsAPIv2() {
+  return {
+    capabilities: () => biometrics_exports.capabilities(),
+    authenticate: (opts) => biometrics_exports.authenticate(opts)
+  };
+}
+function createSharingAPI() {
+  return {
+    isAvailable: () => sharing_exports.isAvailable(),
+    shareFile: (fileUri, opts) => sharing_exports.shareFile(fileUri, opts)
+  };
+}
+function createScannerAPI() {
+  return {
+    requestPermissions: () => scanner_exports.requestPermissions(),
+    // Raises the shared camera surface and settles on the first code read.
+    // The plugin mounts nothing — that lifecycle is owned once, by
+    // CameraTaskHost, instead of by every plugin that wants to scan.
+    scanOnce: (opts) => cameraTasks.run("scan", {
+      formats: opts?.formats,
+      timeoutMs: opts?.timeoutMs
+    })
+  };
+}
+function createNfcAPI() {
+  return {
+    async isSupported() {
+      const mod = getDeviceNfc();
+      if (!mod) return false;
+      return mod.isSupported();
+    },
+    async isEnabled() {
+      const mod = getDeviceNfc();
+      if (!mod) return false;
+      return mod.isEnabled();
+    },
+    readOnce(timeoutMs) {
+      const mod = getDeviceNfc();
+      if (!mod) return Promise.resolve({ ok: false, error: "nfc_unavailable" });
+      return mod.readOnce(timeoutMs);
+    }
+  };
+}
+function createBluetoothAPI() {
+  const refuse = (method) => new CapabilityUnavailableError(
+    `bluetooth.${method}`,
+    "Bluetooth is not implemented in this build \u2014 no BLE native module is installed. The capability is declared so it fails by name rather than silently; nothing was scanned."
+  );
+  return {
+    // These two answer `false` rather than throwing, because "is BLE usable?"
+    // is exactly the question a plugin should be allowed to ask before
+    // committing to a flow, and `false` is the true answer here.
+    async isSupported() {
+      return false;
+    },
+    async isEnabled() {
+      return false;
+    },
+    // scan() THROWS, because there is no honest empty result: an empty device
+    // list is a real finding ("nothing is advertising nearby") and returning
+    // one would report a scan that never happened.
+    async scan() {
+      throw refuse("scan");
+    }
+  };
+}
+function createVisionAPI() {
+  return {
+    // "Can I see?" — true once the native module is present in the binary. On a
+    // build without it, adaVision.isSupported() answers false, and assessQuality
+    // below refuses cleanly (no crash), exactly the pre-module behaviour.
+    async isSupported() {
+      return isSupported();
+    },
+    // readText: on-device OCR on a published frame (native resolves the id →
+    // pixels). [] = looked, found no text (a real finding); throws = could not
+    // look (unknown/aged-out id). describe (VNClassifyImage) is the next pass.
+    async readText(frameId, opts) {
+      return readText(frameId, opts?.languages);
+    },
+    // describe: on-device labels (VNClassifyImage), not prose — the sentence is
+    // the skill's job. [] = looked, recognised nothing.
+    async describe(frameId, opts) {
+      return describe(frameId, opts?.maxLabels ?? 5);
+    },
+    // detectObjects: on-device located objects (bundled detector), each with a
+    // box — what a guidance loop reads to say WHERE a thing is, not just that the
+    // scene contains it. [] = looked, found nothing; throws = could not look.
+    async detectObjects(frameId, opts) {
+      return detectObjects(frameId, opts?.maxItems ?? 10, opts?.minConfidence ?? 0.25);
+    },
+    // assessQuality: resolve the frame id to its LOCAL file, measure on-device,
+    // and record the result back onto the frame so a later read of
+    // VisualFrameRef.quality reflects it. Throwing here means "could not look"
+    // (unknown/aged-out id, or no native module) — never a measured verdict.
+    async assessQuality(frameId) {
+      const q = qualityById(frameId);
+      if (!q) {
+        throw new CapabilityUnavailableError(
+          "vision.assessQuality",
+          `No frame for id "${frameId}" \u2014 unknown or aged out of the ring. This is "could not look", not a measurement.`
+        );
+      }
+      return q;
+    }
+  };
+}
+function createDeviceProvider(config) {
+  const connectivity = createConnectivityAPI(config?.reachabilityUrl);
+  return {
+    camera: createCameraAPI(),
+    location: createLocationAPI(),
+    // Only the per-plugin storageFor/fileSystemFor are exposed — NO shared
+    // `storage`/`fileSystem` bucket. The gate scopes by pluginId and fails
+    // closed without one, so a shared instance would be an unreachable
+    // (and dangerous) fallback. Each plugin gets its own namespace + db file /
+    // sandbox directory, or nothing.
+    storageFor: (pluginId) => createStorageAPI(pluginId),
+    biometrics: stubApi("biometrics"),
+    biometricsV2: createBiometricsAPIv2(),
+    notifications: createNotificationsAPI(),
+    haptics: createHapticsAPI(),
+    connectivity,
+    fileSystemFor: (pluginId) => createFileSystemAPI(pluginId),
+    cookies: createCookiesAPI(),
+    sharing: createSharingAPI(),
+    scanner: createScannerAPI(),
+    nfc: createNfcAPI(),
+    bluetooth: createBluetoothAPI(),
+    vision: createVisionAPI()
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clearAllPluginData,
+  createDeviceProvider
+});
+//# sourceMappingURL=createDeviceProvider.js.map