@ateam-ai-mobile/plugin-runtime 0.1.5 → 0.1.8

package/dist/index.js

@@ -5,6 +5,9 @@ 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 });
@@ -27,118 +30,24 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  ActionButton: () => ActionButton,
-  ActivityIndicator: () => import_react_native.ActivityIndicator,
-  AdaOrb: () => AdaOrb,
-  Animated: () => import_react_native.Animated,
-  Badge: () => Badge,
-  Card: () => Card,
-  EmptyState: () => EmptyState,
-  ErrorState: () => ErrorState,
-  FlatList: () => import_react_native.FlatList,
-  Image: () => import_react_native.Image,
-  ListItem: () => ListItem,
-  LoadingState: () => LoadingState,
-  MemoryBundleStorage: () => MemoryBundleStorage,
-  Modal: () => import_react_native.Modal,
-  Platform: () => import_react_native.Platform,
-  PluginSDK: () => PluginSDK,
-  Pressable: () => import_react_native.Pressable,
-  RefreshControl: () => import_react_native.RefreshControl,
-  ScrollView: () => import_react_native.ScrollView,
-  SearchBar: () => SearchBar,
-  SectionList: () => import_react_native.SectionList,
-  StyleSheet: () => import_react_native.StyleSheet,
-  SurfaceCard: () => SurfaceCard,
-  SurfaceDispatcher: () => SurfaceDispatcher,
-  SurfaceDrawer: () => SurfaceDrawer,
-  SurfaceFullscreen: () => SurfaceFullscreen,
-  Switch: () => import_react_native.Switch,
-  TabBar: () => TabBar,
-  Text: () => import_react_native.Text,
-  TextInput: () => import_react_native.TextInput,
-  TouchableOpacity: () => import_react_native.TouchableOpacity,
-  View: () => import_react_native.View,
-  bundleManager: () => bundleManager,
-  createNativeBridge: () => createNativeBridge,
-  gatePluginNative: () => gatePluginNative,
-  getHaptics: () => getHaptics,
-  getNativeBundleHash: () => getNativeBundleHash,
-  getNativeBundleUrl: () => getNativeBundleUrl,
-  getNativeComponentId: () => getNativeComponentId,
-  getPlugin: () => getPlugin,
-  getPluginNative: () => getPluginNative,
-  isInlineSurface: () => isInlineSurface,
-  isMountSurface: () => isMountSurface,
-  listPlugins: () => listPlugins,
-  nativePluginRegistry: () => nativePluginRegistry,
-  register: () => register,
-  registerBundleModules: () => registerBundleModules,
-  registerNativePlugin: () => registerNativePlugin,
-  registerService: () => registerService,
-  resolvePluginUrl: () => resolvePluginUrl,
-  setBundleStorage: () => setBundleStorage,
-  setHapticsProvider: () => setHapticsProvider,
-  setPluginNativeProvider: () => setPluginNativeProvider,
-  setPluginThemeColors: () => setPluginThemeColors,
-  supportsNative: () => supportsNative,
-  supportsWebView: () => supportsWebView,
-  unregisterNativePlugin: () => unregisterNativePlugin,
-  useApi: () => useApi,
-  useNativeBridge: () => useNativeBridge,
-  usePlugin: () => usePlugin,
-  usePluginTheme: () => usePluginTheme,
-  useRemotePlugins: () => useRemotePlugins,
-  useSurfaceStore: () => useSurfaceStore
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/sdk/index.ts
-var sdk_exports = {};
-__export(sdk_exports, {
-  ActionButton: () => ActionButton,
-  ActivityIndicator: () => import_react_native.ActivityIndicator,
-  Animated: () => import_react_native.Animated,
-  Badge: () => Badge,
-  Card: () => Card,
-  EmptyState: () => EmptyState,
-  ErrorState: () => ErrorState,
-  FlatList: () => import_react_native.FlatList,
-  Image: () => import_react_native.Image,
-  ListItem: () => ListItem,
-  LoadingState: () => LoadingState,
-  Modal: () => import_react_native.Modal,
-  Platform: () => import_react_native.Platform,
-  PluginSDK: () => PluginSDK,
-  Pressable: () => import_react_native.Pressable,
-  RefreshControl: () => import_react_native.RefreshControl,
-  ScrollView: () => import_react_native.ScrollView,
-  SearchBar: () => SearchBar,
-  SectionList: () => import_react_native.SectionList,
-  StyleSheet: () => import_react_native.StyleSheet,
-  Switch: () => import_react_native.Switch,
-  TabBar: () => TabBar,
-  Text: () => import_react_native.Text,
-  TextInput: () => import_react_native.TextInput,
-  TouchableOpacity: () => import_react_native.TouchableOpacity,
-  View: () => import_react_native.View,
-  register: () => register,
-  registerService: () => registerService,
-  setPluginThemeColors: () => setPluginThemeColors,
-  useApi: () => useApi,
-  usePluginTheme: () => usePluginTheme
-});
-
 // src/sdk/registration.ts
 function register(id, config) {
   return {
     id,
     type: config.type || "ui",
     capabilities: config.capabilities,
-    Component: config.Component
+    stateDomains: config.stateDomains,
+    Component: config.Component,
+    tools: config.tools
+  };
+}
+function registerTools(id, config) {
+  return {
+    id,
+    type: "tools",
+    capabilities: config.capabilities,
+    stateDomains: config.stateDomains,
+    tools: config.tools
   };
 }
 function registerService(id, config) {
@@ -151,13 +60,31 @@ function registerService(id, config) {
     onStop: config.onStop
   };
 }
+var init_registration = __esm({
+  "src/sdk/registration.ts"() {
+    "use strict";
+  }
+});
+
+// src/sdk/voice.ts
+var PLATFORM_VOICE_CALLER;
+var init_voice = __esm({
+  "src/sdk/voice.ts"() {
+    "use strict";
+    PLATFORM_VOICE_CALLER = /* @__PURE__ */ Symbol("adas.voice.platform");
+  }
+});
 
 // src/sdk/primitives.ts
-var import_react_native = require("react-native");
+var import_react_native;
+var init_primitives = __esm({
+  "src/sdk/primitives.ts"() {
+    "use strict";
+    import_react_native = require("react-native");
+  }
+});
 
 // src/sdk/components.ts
-var import_react = __toESM(require("react"));
-var import_react_native2 = require("react-native");
 function Card({ theme, children, style, onPress }) {
   const cardStyle = [
     styles.card,
@@ -172,13 +99,6 @@ function Card({ theme, children, style, onPress }) {
   }
   return import_react.default.createElement(import_react_native2.View, { style: cardStyle }, children);
 }
-var BADGE_COLORS = {
-  accent: { bg: "accentSoft", text: "accent" },
-  success: { bg: "successSoft", text: "success" },
-  warning: { bg: "warningSoft", text: "warning" },
-  error: { bg: "errorSoft", text: "error" },
-  purple: { bg: "purpleSoft", text: "purple" }
-};
 function Badge({ theme, label, color = "accent", style }) {
   const mapping = BADGE_COLORS[color];
   return import_react.default.createElement(
@@ -337,105 +257,272 @@ function ActionButton({ theme, label, icon, onPress, style }) {
     icon || import_react.default.createElement(import_react_native2.Text, { style: styles.fabText }, label || "+")
   );
 }
-var styles = import_react_native2.StyleSheet.create({
-  card: {
-    padding: 12,
-    borderRadius: 12,
-    borderWidth: 1,
-    marginBottom: 8
-  },
-  badge: {
-    paddingHorizontal: 8,
-    paddingVertical: 3
-  },
-  badgeText: {
-    fontSize: 11,
-    fontWeight: "600"
-  },
-  tabBar: {
-    flexDirection: "row",
-    borderBottomWidth: 1
-  },
-  tab: {
-    flex: 1,
-    padding: 12,
-    alignItems: "center",
-    borderBottomWidth: 2
-  },
-  listItem: {
-    flexDirection: "row",
-    alignItems: "center",
-    paddingVertical: 12,
-    paddingHorizontal: 16,
-    borderBottomWidth: import_react_native2.StyleSheet.hairlineWidth
-  },
-  listItemContent: {
-    flex: 1
-  },
-  searchBar: {
-    height: 40,
-    paddingHorizontal: 12,
-    borderWidth: 1
-  },
-  emptyState: {
-    flex: 1,
-    justifyContent: "center",
-    alignItems: "center",
-    padding: 32
-  },
-  retryButton: {
-    marginTop: 12,
-    paddingHorizontal: 16,
-    paddingVertical: 8
-  },
-  fab: {
-    position: "absolute",
-    bottom: 24,
-    right: 24,
-    width: 56,
-    height: 56,
-    justifyContent: "center",
-    alignItems: "center",
-    shadowColor: "#000",
-    shadowOffset: { width: 0, height: 2 },
-    shadowOpacity: 0.25,
-    shadowRadius: 4,
-    elevation: 5
-  },
-  fabText: {
-    color: "#fff",
-    fontSize: 24,
-    fontWeight: "600"
+var import_react, import_react_native2, BADGE_COLORS, styles;
+var init_components = __esm({
+  "src/sdk/components.ts"() {
+    "use strict";
+    import_react = __toESM(require("react"));
+    import_react_native2 = require("react-native");
+    BADGE_COLORS = {
+      accent: { bg: "accentSoft", text: "accent" },
+      success: { bg: "successSoft", text: "success" },
+      warning: { bg: "warningSoft", text: "warning" },
+      error: { bg: "errorSoft", text: "error" },
+      purple: { bg: "purpleSoft", text: "purple" }
+    };
+    styles = import_react_native2.StyleSheet.create({
+      card: {
+        padding: 12,
+        borderRadius: 12,
+        borderWidth: 1,
+        marginBottom: 8
+      },
+      badge: {
+        paddingHorizontal: 8,
+        paddingVertical: 3
+      },
+      badgeText: {
+        fontSize: 11,
+        fontWeight: "600"
+      },
+      tabBar: {
+        flexDirection: "row",
+        borderBottomWidth: 1
+      },
+      tab: {
+        flex: 1,
+        padding: 12,
+        alignItems: "center",
+        borderBottomWidth: 2
+      },
+      listItem: {
+        flexDirection: "row",
+        alignItems: "center",
+        paddingVertical: 12,
+        paddingHorizontal: 16,
+        borderBottomWidth: import_react_native2.StyleSheet.hairlineWidth
+      },
+      listItemContent: {
+        flex: 1
+      },
+      searchBar: {
+        height: 40,
+        paddingHorizontal: 12,
+        borderWidth: 1
+      },
+      emptyState: {
+        flex: 1,
+        justifyContent: "center",
+        alignItems: "center",
+        padding: 32
+      },
+      retryButton: {
+        marginTop: 12,
+        paddingHorizontal: 16,
+        paddingVertical: 8
+      },
+      fab: {
+        position: "absolute",
+        bottom: 24,
+        right: 24,
+        width: 56,
+        height: 56,
+        justifyContent: "center",
+        alignItems: "center",
+        shadowColor: "#000",
+        shadowOffset: { width: 0, height: 2 },
+        shadowOpacity: 0.25,
+        shadowRadius: 4,
+        elevation: 5
+      },
+      fabText: {
+        color: "#fff",
+        fontSize: 24,
+        fontWeight: "600"
+      }
+    });
+  }
+});
+
+// src/host.ts
+function setHapticsProvider(haptics) {
+  _haptics = haptics;
+}
+function getHaptics() {
+  return _haptics;
+}
+function unavailable(api) {
+  return new Proxy({}, {
+    get: (_t, method) => () => Promise.reject(new Error(`[adas] native.${api}.${String(method)} unavailable \u2014 host did not call setPluginNativeProvider()`))
+  });
+}
+function setPluginNativeProvider(native) {
+  _pluginNative = native;
+}
+function getPluginNative() {
+  return _pluginNative;
+}
+function blocked(api, reason) {
+  return new Proxy({}, {
+    get: (_t, method) => {
+      if (typeof method !== "string") return void 0;
+      return () => {
+        console.warn(`[adas] native.${api}.${method} blocked \u2014 ${reason ?? `capability '${api}' not declared in the plugin manifest`}`);
+      };
+    }
+  });
+}
+function gatePluginNative(native, declared, pluginId) {
+  const caps = declared || {};
+  const scopedFileSystem = native.fileSystemFor && pluginId ? native.fileSystemFor(pluginId) : null;
+  const scopedStorage = native.storageFor && pluginId ? native.storageFor(pluginId) : null;
+  const gated = {
+    camera: caps.camera ? native.camera : blocked("camera"),
+    location: caps.location ? native.location : blocked("location"),
+    storage: caps.offline ? scopedStorage ?? blocked("storage", "no trusted pluginId to scope storage \u2014 refusing shared access (fail closed)") : blocked("storage"),
+    biometrics: caps.biometrics ? native.biometrics : blocked("biometrics"),
+    biometricsV2: caps.biometricsV2 ? native.biometricsV2 : blocked("biometricsV2"),
+    notifications: caps.notifications ? native.notifications : blocked("notifications"),
+    haptics: caps.haptics ? native.haptics : blocked("haptics"),
+    connectivity: native.connectivity,
+    fileSystem: caps.fileSystem ? scopedFileSystem ?? blocked("fileSystem", "no trusted pluginId to scope the filesystem \u2014 refusing shared access (fail closed)") : blocked("fileSystem"),
+    cookies: caps.cookies ? native.cookies : blocked("cookies"),
+    sharing: caps.sharing ? native.sharing : blocked("sharing"),
+    scanner: caps.scanner ? native.scanner : blocked("scanner"),
+    nfc: caps.nfc ? native.nfc : blocked("nfc"),
+    // Gated like the rest even though nothing implements it yet. An undeclared
+    // plugin gets the usual blocked proxy; a DECLARED one reaches an API whose
+    // every method refuses by name. Both are better than the `undefined` this
+    // used to be, which crashed with "cannot read properties of undefined".
+    bluetooth: caps.bluetooth ? native.bluetooth : blocked("bluetooth"),
+    vision: caps.vision ? native.vision : blocked("vision"),
+    maps: caps.maps ? native.maps : blocked("maps")
+    // What this plugin DECLARED, carried on the object it already receives.
+    //
+    // It is how a COMPONENT can be capability-gated: <CameraPreview> is handed
+    // `native` and reads this, so showing the camera obeys the same flag as
+    // calling it. Without this the preview would be a second door to the camera
+    // with only one lock. Non-enumerable so it cannot be mistaken for an API.
+  };
+  Object.defineProperty(gated, "__declaredCapabilities", {
+    value: Object.freeze({ ...caps }),
+    enumerable: false,
+    writable: false
+  });
+  return gated;
+}
+function setCameraPreviewProvider(Component) {
+  _cameraPreview = Component;
+}
+function getCameraPreviewProvider() {
+  return _cameraPreview;
+}
+function registerNativePlugin(id, plugin) {
+  _nativeRegistry.set(id, plugin);
+}
+function unregisterNativePlugin(id) {
+  _nativeRegistry.delete(id);
+}
+function registerBundleModules(modules) {
+  for (const [name, mod] of Object.entries(modules)) {
+    _bundleModules.set(name, mod);
+  }
+}
+function resolveBundleModule(name) {
+  return _bundleModules.get(name);
+}
+var _haptics, noopNative, _pluginNative, _cameraPreview, _nativeRegistry, nativePluginRegistry, _bundleModules;
+var init_host = __esm({
+  "src/host.ts"() {
+    "use strict";
+    _haptics = null;
+    noopNative = {
+      camera: unavailable("camera"),
+      location: unavailable("location"),
+      storage: unavailable("storage"),
+      biometrics: unavailable("biometrics"),
+      biometricsV2: unavailable("biometricsV2"),
+      notifications: unavailable("notifications"),
+      haptics: { impact: () => {
+      }, notification: () => {
+      }, selection: () => {
+      }, error: () => {
+      } },
+      connectivity: { isOnline: () => true, onChange: () => () => {
+      } },
+      fileSystem: unavailable("fileSystem"),
+      cookies: unavailable("cookies"),
+      sharing: unavailable("sharing"),
+      scanner: unavailable("scanner"),
+      nfc: unavailable("nfc"),
+      bluetooth: unavailable("bluetooth"),
+      vision: unavailable("vision"),
+      maps: unavailable("maps")
+    };
+    _pluginNative = noopNative;
+    _cameraPreview = null;
+    _nativeRegistry = /* @__PURE__ */ new Map();
+    nativePluginRegistry = {
+      has(id) {
+        return _nativeRegistry.has(id);
+      },
+      async get(id) {
+        const entry = _nativeRegistry.get(id);
+        if (!entry) return null;
+        if (typeof entry === "function") {
+          try {
+            return await entry();
+          } catch (err) {
+            console.warn(`[adas-plugins] lazy native plugin '${id}' failed to load:`, err);
+            return null;
+          }
+        }
+        return entry;
+      }
+    };
+    _bundleModules = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/sdk/CameraPreview.tsx
+function declaredCapabilities(native) {
+  return native && native.__declaredCapabilities || null;
+}
+function CameraPreview({ native, facing = "back", style, renderUnavailable }) {
+  const caps = declaredCapabilities(native);
+  if (caps && !caps.camera) {
+    return unavailable2(
+      "this plugin did not declare `capabilities: { camera: true }`, so it may not show the camera",
+      renderUnavailable,
+      style
+    );
+  }
+  const Provider = getCameraPreviewProvider();
+  if (!Provider) {
+    return unavailable2(
+      "this app does not provide a camera preview (the host has not called setCameraPreviewProvider)",
+      renderUnavailable,
+      style
+    );
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Provider, { facing, style, renderUnavailable });
+}
+function unavailable2(reason, render, style) {
+  if (render) return render(reason);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native.View, { style: [{ flex: 1, backgroundColor: "#000", alignItems: "center", justifyContent: "center", padding: 20 }, style], children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native.Text, { style: { color: "#39FF66", fontSize: 12, textAlign: "center" }, children: `NO CAMERA PREVIEW
+${reason}` }) });
+}
+var import_jsx_runtime;
+var init_CameraPreview = __esm({
+  "src/sdk/CameraPreview.tsx"() {
+    "use strict";
+    init_primitives();
+    init_host();
+    import_jsx_runtime = require("react/jsx-runtime");
   }
 });
 
 // src/sdk/usePluginTheme.ts
-var import_react2 = require("react");
-var import_react_native3 = require("react-native");
-var import_core = require("@ateam-ai-mobile/core");
-var adaColors = {
-  bg: import_core.ada.paper,
-  surface: import_core.ada.paperSoft,
-  surfaceAlt: import_core.ada.paperDeep,
-  input: import_core.ada.paper,
-  border: import_core.ada.border,
-  text: import_core.ada.ink,
-  textSecondary: import_core.ada.inkSoft,
-  textMuted: import_core.ada.inkMuted,
-  accent: import_core.ada.orange,
-  accentSoft: import_core.ada.orangeSoft,
-  success: "#5A8A5C",
-  successSoft: "rgba(90,138,92,0.14)",
-  warning: "#D49A4E",
-  warningSoft: "rgba(212,154,78,0.16)",
-  error: "#C15545",
-  errorSoft: "rgba(193,85,69,0.14)",
-  purple: import_core.ada.orangeDeep,
-  purpleSoft: import_core.ada.orangeSoft
-};
-var _colors = adaColors;
-var _isDark = null;
-var _subscribers = /* @__PURE__ */ new Set();
 function setPluginThemeColors(colors, opts) {
   _colors = { ...adaColors, ...colors };
   if (opts?.isDark !== void 0) _isDark = opts.isDark;
@@ -478,9 +565,40 @@ function usePluginTheme() {
     isDark
   }), [colors, isDark]);
 }
+var import_react2, import_react_native3, import_core, adaColors, _colors, _isDark, _subscribers;
+var init_usePluginTheme = __esm({
+  "src/sdk/usePluginTheme.ts"() {
+    "use strict";
+    import_react2 = require("react");
+    import_react_native3 = require("react-native");
+    import_core = require("@ateam-ai-mobile/core");
+    adaColors = {
+      bg: import_core.ada.paper,
+      surface: import_core.ada.paperSoft,
+      surfaceAlt: import_core.ada.paperDeep,
+      input: import_core.ada.paper,
+      border: import_core.ada.border,
+      text: import_core.ada.ink,
+      textSecondary: import_core.ada.inkSoft,
+      textMuted: import_core.ada.inkMuted,
+      accent: import_core.ada.orange,
+      accentSoft: import_core.ada.orangeSoft,
+      success: "#5A8A5C",
+      successSoft: "rgba(90,138,92,0.14)",
+      warning: "#D49A4E",
+      warningSoft: "rgba(212,154,78,0.16)",
+      error: "#C15545",
+      errorSoft: "rgba(193,85,69,0.14)",
+      purple: import_core.ada.orangeDeep,
+      purpleSoft: import_core.ada.orangeSoft
+    };
+    _colors = adaColors;
+    _isDark = null;
+    _subscribers = /* @__PURE__ */ new Set();
+  }
+});
 
 // src/sdk/useApi.ts
-var import_react3 = require("react");
 function useApi(bridge) {
   return (0, import_react3.useMemo)(() => {
     const apiFn = async (connectorId, tool, args = {}) => {
@@ -509,131 +627,767 @@ function useApi(bridge) {
     return apiFn;
   }, [bridge]);
 }
+var import_react3;
+var init_useApi = __esm({
+  "src/sdk/useApi.ts"() {
+    "use strict";
+    import_react3 = require("react");
+  }
+});
 
 // src/sdk/index.ts
-var PluginSDK = { register, registerService };
-
-// src/host.ts
-var _haptics = null;
-function setHapticsProvider(haptics) {
-  _haptics = haptics;
-}
-function getHaptics() {
-  return _haptics;
-}
-function unavailable(api) {
-  return new Proxy({}, {
-    get: (_t, method) => () => Promise.reject(new Error(`[adas] native.${api}.${String(method)} unavailable \u2014 host did not call setPluginNativeProvider()`))
-  });
-}
-var noopNative = {
-  camera: unavailable("camera"),
-  location: unavailable("location"),
-  storage: unavailable("storage"),
-  biometrics: unavailable("biometrics"),
-  biometricsV2: unavailable("biometricsV2"),
-  notifications: unavailable("notifications"),
-  haptics: { impact: () => {
-  }, notification: () => {
-  }, selection: () => {
-  } },
-  connectivity: { isOnline: () => true, onChange: () => () => {
-  } },
-  fileSystem: unavailable("fileSystem"),
-  cookies: unavailable("cookies"),
-  sharing: unavailable("sharing"),
-  scanner: unavailable("scanner"),
-  nfc: unavailable("nfc")
-};
-var _pluginNative = noopNative;
-function setPluginNativeProvider(native) {
-  _pluginNative = native;
-}
-function getPluginNative() {
-  return _pluginNative;
-}
-function blocked(api) {
-  return new Proxy({}, {
-    get: (_t, method) => {
-      if (typeof method !== "string") return void 0;
-      return () => {
-        console.warn(`[adas] native.${api}.${method} blocked \u2014 capability '${api}' not declared in the plugin manifest`);
-      };
-    }
-  });
-}
-function gatePluginNative(native, declared) {
-  const caps = declared || {};
+var sdk_exports = {};
+__export(sdk_exports, {
+  ActionButton: () => ActionButton,
+  ActivityIndicator: () => import_react_native.ActivityIndicator,
+  Animated: () => import_react_native.Animated,
+  Badge: () => Badge,
+  CameraPreview: () => CameraPreview,
+  Card: () => Card,
+  EmptyState: () => EmptyState,
+  ErrorState: () => ErrorState,
+  FlatList: () => import_react_native.FlatList,
+  Image: () => import_react_native.Image,
+  ListItem: () => ListItem,
+  LoadingState: () => LoadingState,
+  Modal: () => import_react_native.Modal,
+  PLATFORM_VOICE_CALLER: () => PLATFORM_VOICE_CALLER,
+  Platform: () => import_react_native.Platform,
+  PluginSDK: () => PluginSDK,
+  Pressable: () => import_react_native.Pressable,
+  RefreshControl: () => import_react_native.RefreshControl,
+  ScrollView: () => import_react_native.ScrollView,
+  SearchBar: () => SearchBar,
+  SectionList: () => import_react_native.SectionList,
+  StyleSheet: () => import_react_native.StyleSheet,
+  Switch: () => import_react_native.Switch,
+  TabBar: () => TabBar,
+  Text: () => import_react_native.Text,
+  TextInput: () => import_react_native.TextInput,
+  TouchableOpacity: () => import_react_native.TouchableOpacity,
+  View: () => import_react_native.View,
+  register: () => register,
+  registerService: () => registerService,
+  registerTools: () => registerTools,
+  setPluginThemeColors: () => setPluginThemeColors,
+  useApi: () => useApi,
+  usePluginTheme: () => usePluginTheme
+});
+var PluginSDK;
+var init_sdk = __esm({
+  "src/sdk/index.ts"() {
+    "use strict";
+    init_registration();
+    init_registration();
+    init_voice();
+    init_primitives();
+    init_components();
+    init_CameraPreview();
+    init_usePluginTheme();
+    init_useApi();
+    PluginSDK = { register, registerService, registerTools };
+  }
+});
+
+// src/deviceStateHost.ts
+function deniedSnapshot(domain) {
+  const base = { quality: UNKNOWN_QUALITY };
+  switch (domain) {
+    case "spatial":
+      return {
+        ...base,
+        position: null,
+        movement: { speedMps: null, bearingDeg: null, distanceRecentM: null, state: "unknown" },
+        orientation: { headingDeg: null },
+        recentPath: []
+      };
+    case "visual":
+      return {
+        ...base,
+        camera: { available: false, active: false, facing: "unknown" },
+        latest: null,
+        recentTimeline: { windowMs: 0, frames: [] }
+      };
+    case "deviceContext":
+      return {
+        ...base,
+        power: { batteryLevel: null, charging: null, lowPowerMode: null },
+        thermal: { state: "unknown" },
+        resources: { memoryPressure: "unknown", storagePressure: "unknown" }
+      };
+    case "connectivity":
+      return {
+        ...base,
+        reachability: "unknown",
+        transport: "unknown",
+        qualityClass: "unknown",
+        stability: "unknown",
+        latencyMs: null
+      };
+    case "interaction":
+      return {
+        ...base,
+        lifecycle: { appState: "unknown", screenOn: null },
+        audio: { captureActive: null, playbackActive: null, route: "unknown", interruption: "unknown" }
+      };
+    case "activity":
+      return {
+        ...base,
+        // `confidence` is REQUIRED on both blocks in the freeze, precisely
+        // because an inferred activity must never be handed over without
+        // saying how sure the inference is. An empty snapshot is the least
+        // sure of all.
+        human: { state: "unknown", since: null, confidence: { level: "unknown" } },
+        devicePose: { placement: "unknown", orientation: "unknown", confidence: { level: "unknown" } },
+        recentTransitions: []
+      };
+    case "environment":
+      return {
+        ...base,
+        lighting: { level: "unknown", lux: null },
+        acoustics: { level: "unknown", approximateDb: null },
+        // 'unknown' rather than 'uncertain': uncertain means we looked and
+        // could not decide, and nothing looked at all here.
+        enclosure: { state: "unknown" },
+        proximity: { distanceClass: "unknown" },
+        nearbySignals: { bleAvailable: false, beaconCount: null, uwbAvailable: false }
+      };
+    case "capability": {
+      const unknownStatus = { support: "unknown", permission: "unknown", availability: "unknown" };
+      return {
+        ...base,
+        camera: unknownStatus,
+        microphone: unknownStatus,
+        location: { ...unknownStatus, precision: "unknown", backgroundPermission: "unknown" },
+        motion: unknownStatus,
+        bluetooth: unknownStatus,
+        uwb: unknownStatus,
+        nfc: unknownStatus,
+        notifications: unknownStatus,
+        health: unknownStatus,
+        backgroundExecution: unknownStatus
+      };
+    }
+    default:
+      return base;
+  }
+}
+function deniedDomain(domain, why) {
   return {
-    camera: caps.camera ? native.camera : blocked("camera"),
-    location: caps.location ? native.location : blocked("location"),
-    storage: caps.offline ? native.storage : blocked("storage"),
-    biometrics: caps.biometrics ? native.biometrics : blocked("biometrics"),
-    biometricsV2: caps.biometricsV2 ? native.biometricsV2 : blocked("biometricsV2"),
-    notifications: caps.notifications ? native.notifications : blocked("notifications"),
-    haptics: caps.haptics ? native.haptics : blocked("haptics"),
-    connectivity: native.connectivity,
-    fileSystem: caps.fileSystem ? native.fileSystem : blocked("fileSystem"),
-    cookies: caps.cookies ? native.cookies : blocked("cookies"),
-    sharing: caps.sharing ? native.sharing : blocked("sharing"),
-    scanner: caps.scanner ? native.scanner : blocked("scanner"),
-    nfc: caps.nfc ? native.nfc : blocked("nfc")
+    async getSnapshot() {
+      return deniedSnapshot(domain);
+    },
+    async start() {
+      throw denial(domain, why);
+    },
+    async stop() {
+      throw denial(domain, why);
+    },
+    subscribe() {
+      throw denial(domain, why);
+    }
+  };
+}
+function denial(domain, why) {
+  const err = new Error(`deviceState.${domain}: ${why}`);
+  err.code = "RESTRICTED";
+  err.domain = domain;
+  return err;
+}
+function setDeviceStateProvider(state) {
+  _provider = state || {};
+}
+function gateDeviceState(declared) {
+  const allowed = new Set(declared || []);
+  const out = {};
+  for (const domain of ALL_DOMAINS) {
+    if (!allowed.has(domain)) {
+      out[domain] = deniedDomain(
+        domain,
+        `not declared in this plugin's stateDomains. Add '${domain}' to use it.`
+      );
+      continue;
+    }
+    const engine = _provider[domain];
+    out[domain] = engine ?? deniedDomain(
+      domain,
+      "no engine in this build \u2014 the native side does not exist yet. See docs/DEVICE_API_STATUS.md."
+    );
+  }
+  return out;
+}
+function withoutSubscribe(state) {
+  if (!state) return state;
+  const out = {};
+  for (const domain of ALL_DOMAINS) {
+    const d = state[domain];
+    out[domain] = d && Object.assign(Object.create(d), {
+      subscribe() {
+        throw denial(domain, "a device tool call has no lifetime to own a subscription. Subscribe from the plugin UI, or read getSnapshot() within the call.");
+      }
+    });
+  }
+  return out;
+}
+function implementedStateDomains() {
+  return ALL_DOMAINS.filter((d) => !!_provider[d]);
+}
+var UNKNOWN_QUALITY, ALL_DOMAINS, _provider;
+var init_deviceStateHost = __esm({
+  "src/deviceStateHost.ts"() {
+    "use strict";
+    UNKNOWN_QUALITY = {
+      freshness: { state: "unknown", observedAt: null, ageMs: null },
+      confidence: { level: "unknown" }
+    };
+    ALL_DOMAINS = [
+      "spatial",
+      "visual",
+      "activity",
+      "deviceContext",
+      "connectivity",
+      "capability",
+      "environment",
+      "interaction"
+    ];
+    _provider = {};
+  }
+});
+
+// src/voiceHost.ts
+function setVoiceProvider(provider) {
+  _provider2 = provider || null;
+}
+function implementedVoice() {
+  return !!_provider2;
+}
+function voiceDenial(why) {
+  const err = new Error(`voice: ${why}`);
+  err.code = "RESTRICTED";
+  return err;
+}
+function deniedVoice(why) {
+  const fail = () => {
+    throw voiceDenial(why);
+  };
+  return {
+    async start() {
+      return fail();
+    },
+    stop() {
+      fail();
+    },
+    setMuted() {
+      fail();
+    },
+    prompt() {
+      fail();
+    },
+    observe() {
+      fail();
+    },
+    getSnapshot() {
+      return {
+        state: "error",
+        sessionId: null,
+        muted: false,
+        speaking: false,
+        listening: false,
+        userSpeaking: false,
+        lastUserSpeechEndedAt: null,
+        lastDeviceTool: null,
+        authorizedSessionId: null,
+        lastError: why
+      };
+    },
+    subscribe() {
+      return fail();
+    },
+    transcript() {
+      return [];
+    }
+  };
+}
+function scopedVoice(provider, pluginId) {
+  return {
+    start: (opts) => provider.start(opts, pluginId),
+    stop: () => provider.stop(pluginId),
+    setMuted: (muted) => provider.setMuted(muted, pluginId),
+    prompt: (input) => provider.prompt(input, pluginId),
+    observe: (text) => provider.observe(text, pluginId),
+    getSnapshot: () => provider.getSnapshot(pluginId),
+    subscribe: (cb) => provider.subscribe(cb, pluginId),
+    transcript: () => provider.transcript(pluginId)
+  };
+}
+function gateVoice(declared, pluginId) {
+  if (!declared) {
+    return deniedVoice(
+      "not declared in this plugin's capabilities. Add `capabilities: { voice: true }` to use it."
+    );
+  }
+  if (!pluginId) {
+    return deniedVoice(
+      "no plugin identity \u2014 voice fails closed without a caller to scope the session to."
+    );
+  }
+  return _provider2 ? scopedVoice(_provider2, pluginId) : deniedVoice(
+    "no voice session in this build \u2014 the app has not mounted a VoiceSessionHost / called setVoiceProvider."
+  );
+}
+var _provider2;
+var init_voiceHost = __esm({
+  "src/voiceHost.ts"() {
+    "use strict";
+    _provider2 = null;
+  }
+});
+
+// src/pluginRuntime.ts
+function mergeCaps(decl) {
+  if (!decl) return void 0;
+  return { ...decl.native, ...decl.capabilities };
+}
+function resolvePluginGrants(src) {
+  const trusted = src.manifest ?? src.plugin ?? null;
+  const stateDomains = trusted?.stateDomains ? [...trusted.stateDomains] : void 0;
+  return { capabilities: mergeCaps(trusted), stateDomains };
+}
+function resolvePluginRuntimeProps(src) {
+  const { capabilities, stateDomains } = resolvePluginGrants(src);
+  const native = gatePluginNative(getPluginNative(), capabilities, src.pluginId);
+  const deviceState = gateDeviceState(stateDomains);
+  const voice = gateVoice(!!capabilities?.voice, src.pluginId);
+  return { device: native, native, deviceState, voice };
+}
+var init_pluginRuntime = __esm({
+  "src/pluginRuntime.ts"() {
+    "use strict";
+    init_host();
+    init_deviceStateHost();
+    init_voiceHost();
+  }
+});
+
+// src/bridge/native.ts
+function buildContext(pluginId, connectorId) {
+  const user = (0, import_core2.getUser)();
+  return {
+    tenant: (0, import_core2.getTenant)(),
+    pluginId,
+    connectorId,
+    user: user ? { id: user.actorId || "", name: user.name || "", roles: user.roles || [] } : void 0
+  };
+}
+function useNativeBridge(pluginId, connectorId, commandBufferRef) {
+  const initCallbackRef = (0, import_react4.useRef)(null);
+  const commandListenersRef = (0, import_react4.useRef)(/* @__PURE__ */ new Set());
+  const initializedRef = (0, import_react4.useRef)(false);
+  const fireInit = (0, import_react4.useCallback)(() => {
+    if (initializedRef.current || !initCallbackRef.current) return;
+    initCallbackRef.current(buildContext(pluginId, connectorId));
+    initializedRef.current = true;
+  }, [pluginId, connectorId]);
+  const onInit = (0, import_react4.useCallback)((cb) => {
+    initCallbackRef.current = cb;
+    setTimeout(fireInit, 0);
+  }, [fireInit]);
+  const mcpCall = (0, import_react4.useCallback)(async (toolOrConnector, argsOrTool, cIdOrArgs) => {
+    let tool;
+    let args;
+    let cId;
+    if (typeof argsOrTool === "string") {
+      cId = toolOrConnector;
+      tool = argsOrTool;
+      args = cIdOrArgs || {};
+    } else {
+      tool = toolOrConnector;
+      args = argsOrTool;
+      cId = typeof cIdOrArgs === "string" ? cIdOrArgs : void 0;
+    }
+    const targetConnector = cId || connectorId;
+    if (!targetConnector) {
+      console.warn(`[NativeBridge:${pluginId}] mcpCall failed \u2014 no connectorId. tool=${tool}`);
+      throw new Error(`[NativeBridge:${pluginId}] mcpCall requires a connectorId`);
+    }
+    try {
+      const data = await (0, import_core2.connectorCall)(targetConnector, tool, args);
+      if (!data.ok && data.error) {
+        throw new Error(data.error);
+      }
+      return (0, import_core2.unwrapMcpResult)(data.result);
+    } catch (err) {
+      console.warn(`[NativeBridge:${pluginId}] mcpCall failed \u2192 connector=${targetConnector} tool=${tool}:`, err?.message || err);
+      throw err;
+    }
+  }, [pluginId, connectorId]);
+  const mcpFetch = (0, import_react4.useCallback)(async (body) => {
+    return (0, import_core2.mcpFetch)(body);
+  }, []);
+  const sendCommand = (0, import_react4.useCallback)((type, payload) => {
+    if (type === "plugin.command.result" && payload?.correlationId) {
+      (0, import_core2.postCommandResult)(payload.correlationId, payload.result, payload.error);
+      return;
+    }
+  }, [pluginId]);
+  const onCommand = (0, import_react4.useCallback)((cb) => {
+    commandListenersRef.current.add(cb);
+    if (commandBufferRef) {
+      const buf = commandBufferRef.current;
+      const remaining = [];
+      for (const cmd of buf) {
+        if (cmd.pluginId === pluginId && cmd.command !== "__focus") {
+          try {
+            cb(cmd.command, { ...cmd.args, correlationId: cmd.correlationId });
+          } catch {
+          }
+        } else {
+          remaining.push(cmd);
+        }
+      }
+      commandBufferRef.current = remaining;
+    }
+    for (const cmd of import_core2.pluginCommandEmitter.drainPluginCommands(pluginId)) {
+      try {
+        cb(cmd.command, { ...cmd.args, correlationId: cmd.correlationId });
+      } catch {
+      }
+    }
+    return () => {
+      commandListenersRef.current.delete(cb);
+    };
+  }, [pluginId, commandBufferRef]);
+  (0, import_react4.useEffect)(() => {
+    const unsub = import_core2.pluginCommandEmitter.on("plugin-command", (cmd) => {
+      if (cmd.pluginId !== pluginId) return;
+      if (cmd.command === "__focus") return;
+      commandListenersRef.current.forEach((fn) => {
+        try {
+          fn(cmd.command, { ...cmd.args, correlationId: cmd.correlationId });
+        } catch {
+        }
+      });
+    });
+    return unsub;
+  }, [pluginId]);
+  (0, import_react4.useEffect)(() => {
+    const timer = setTimeout(() => {
+      const dispatch = (cmd) => {
+        commandListenersRef.current.forEach((fn) => {
+          try {
+            fn(cmd.command, { ...cmd.args, correlationId: cmd.correlationId });
+          } catch {
+          }
+        });
+      };
+      if (commandBufferRef) {
+        const remaining = [];
+        for (const cmd of commandBufferRef.current) {
+          if (cmd.pluginId === pluginId && cmd.command !== "__focus") dispatch(cmd);
+          else remaining.push(cmd);
+        }
+        commandBufferRef.current = remaining;
+      }
+      for (const cmd of import_core2.pluginCommandEmitter.drainPluginCommands(pluginId)) {
+        dispatch(cmd);
+      }
+    }, 500);
+    return () => clearTimeout(timer);
+  }, [pluginId, commandBufferRef]);
+  (0, import_react4.useEffect)(() => {
+    return () => {
+      commandListenersRef.current.clear();
+      initializedRef.current = false;
+    };
+  }, []);
+  const close = (0, import_react4.useCallback)(() => {
+    import_core2.pluginCommandEmitter.emit("plugin-close", { pluginId });
+  }, [pluginId]);
+  const sendMessage = (0, import_react4.useCallback)((text) => {
+    const t = (text || "").trim();
+    if (!t) return;
+    try {
+      import_core2.useChatStore.getState().sendMessage(t);
+    } catch (err) {
+      console.warn("[bridge.sendMessage] failed:", err instanceof Error ? err.message : String(err));
+    }
+  }, []);
+  const prepareMessage = (0, import_react4.useCallback)((text) => {
+    const t = (text || "").trim();
+    if (!t) return;
+    import_core2.pluginCommandEmitter.emit("prepare-chat-message", { text: t });
+  }, []);
+  return (0, import_react4.useMemo)(
+    () => ({ onInit, mcpCall, mcpFetch, sendCommand, onCommand, close, sendMessage, prepareMessage }),
+    [onInit, mcpCall, mcpFetch, sendCommand, onCommand, close, sendMessage, prepareMessage]
+  );
+}
+function createNativeBridge(pluginId, connectorId) {
+  const commandListeners = /* @__PURE__ */ new Set();
+  return {
+    onInit(cb) {
+      setTimeout(() => {
+        cb(buildContext(pluginId, connectorId));
+      }, 0);
+    },
+    async mcpCall(tool, args, cId) {
+      const targetConnector = cId || connectorId;
+      if (!targetConnector) {
+        throw new Error(`[NativeBridge:${pluginId}] mcpCall requires a connectorId`);
+      }
+      const data = await (0, import_core2.connectorCall)(targetConnector, tool, args);
+      if (!data.ok && data.error) throw new Error(data.error);
+      return (0, import_core2.unwrapMcpResult)(data.result);
+    },
+    async mcpFetch(body) {
+      return (0, import_core2.mcpFetch)(body);
+    },
+    sendCommand(_type, _payload) {
+    },
+    onCommand(cb) {
+      commandListeners.add(cb);
+      return () => {
+        commandListeners.delete(cb);
+      };
+    },
+    close() {
+      import_core2.pluginCommandEmitter.emit("plugin-close", { pluginId });
+    },
+    sendMessage(text) {
+      const t = (text || "").trim();
+      if (!t) return;
+      try {
+        import_core2.useChatStore.getState().sendMessage(t);
+      } catch (err) {
+        console.warn("[bridge.sendMessage] failed:", err instanceof Error ? err.message : String(err));
+      }
+    },
+    prepareMessage(text) {
+      const t = (text || "").trim();
+      if (!t) return;
+      import_core2.pluginCommandEmitter.emit("prepare-chat-message", { text: t });
+    }
   };
 }
-var _nativeRegistry = /* @__PURE__ */ new Map();
-function registerNativePlugin(id, plugin) {
-  _nativeRegistry.set(id, plugin);
+var import_react4, import_core2;
+var init_native = __esm({
+  "src/bridge/native.ts"() {
+    "use strict";
+    import_react4 = require("react");
+    import_core2 = require("@ateam-ai-mobile/core");
+  }
+});
+
+// src/tools/registry.ts
+function setDeviceToolContextProvider(fn) {
+  contextProvider = fn;
 }
-function unregisterNativePlugin(id) {
-  _nativeRegistry.delete(id);
+function defaultContext(pluginId, capabilities, stateDomains) {
+  return {
+    bridge: createNativeBridge(pluginId),
+    native: gatePluginNative(getPluginNative(), capabilities, pluginId),
+    deviceState: gateDeviceState(stateDomains)
+  };
 }
-var nativePluginRegistry = {
-  has(id) {
-    return _nativeRegistry.has(id);
-  },
-  async get(id) {
-    const entry = _nativeRegistry.get(id);
-    if (!entry) return null;
-    if (typeof entry === "function") {
-      try {
-        return await entry();
-      } catch (err) {
-        console.warn(`[adas-plugins] lazy native plugin '${id}' failed to load:`, err);
-        return null;
-      }
+function registerDeviceTools(pluginId, tools, capabilities, stateDomains) {
+  const accepted = [];
+  for (const tool of tools || []) {
+    if (!tool || typeof tool.name !== "string" || typeof tool.run !== "function") {
+      console.warn(`[deviceTools] ${pluginId}: skipping malformed tool entry`);
+      continue;
+    }
+    const existing = registry.get(tool.name);
+    if (existing && existing.pluginId !== pluginId) {
+      console.warn(
+        `[deviceTools] ${pluginId}: "${tool.name}" already registered by ${existing.pluginId} \u2014 refusing to override`
+      );
+      continue;
     }
-    return entry;
+    registry.set(tool.name, { pluginId, tool, capabilities, stateDomains });
+    accepted.push(tool.name);
   }
-};
-var _bundleModules = /* @__PURE__ */ new Map();
-function registerBundleModules(modules) {
-  for (const [name, mod] of Object.entries(modules)) {
-    _bundleModules.set(name, mod);
+  if (accepted.length > 0) {
+    console.log(`[deviceTools] ${pluginId} registered: ${accepted.join(", ")}`);
   }
+  return accepted;
 }
-function resolveBundleModule(name) {
-  return _bundleModules.get(name);
+function unregisterDeviceTools(pluginId) {
+  for (const [name, entry] of registry.entries()) {
+    if (entry.pluginId === pluginId) registry.delete(name);
+  }
 }
+function hasDeviceTool(name, pluginId) {
+  const entry = registry.get(name);
+  return !!entry && (pluginId === void 0 || entry.pluginId === pluginId);
+}
+function listDeviceTools() {
+  return Array.from(registry.entries()).map(([name, { pluginId, tool }]) => ({
+    name,
+    pluginId,
+    description: tool.description,
+    input_schema: tool.input_schema
+  }));
+}
+async function callDeviceTool(name, args = {}, opts = {}) {
+  const entry = registry.get(name);
+  if (!entry) {
+    return { ok: false, reason: "not_found", error: `No device tool registered as "${name}"` };
+  }
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  let timer;
+  try {
+    const build = contextProvider || defaultContext;
+    const built = build(entry.pluginId, entry.capabilities, entry.stateDomains);
+    const ctx = {
+      ...built,
+      // Whoever built the context, a call cannot own a subscription.
+      deviceState: withoutSubscribe(built.deviceState),
+      signal: opts.signal
+    };
+    const result = await Promise.race([
+      Promise.resolve(entry.tool.run(args, ctx)),
+      new Promise((_, reject) => {
+        timer = setTimeout(
+          () => reject(new Error(`Device tool "${name}" timed out after ${timeoutMs}ms`)),
+          timeoutMs
+        );
+      })
+    ]);
+    return { ok: true, result };
+  } catch (err) {
+    const message = err?.message || String(err);
+    const timedOut = message.includes("timed out after");
+    return { ok: false, reason: timedOut ? "timeout" : "failed", error: message };
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+function clearDeviceTools() {
+  registry.clear();
+}
+var registry, contextProvider, DEFAULT_TIMEOUT_MS;
+var init_registry = __esm({
+  "src/tools/registry.ts"() {
+    "use strict";
+    init_native();
+    init_host();
+    init_deviceStateHost();
+    registry = /* @__PURE__ */ new Map();
+    contextProvider = null;
+    DEFAULT_TIMEOUT_MS = 3e4;
+  }
+});
 
-// src/bundles/bundleManager.ts
-var import_react8 = __toESM(require("react"));
-var import_react9 = require("react");
-var ReactNative = __toESM(require("react-native"));
-var import_core6 = require("@ateam-ai-mobile/core");
-
-// src/surfaces/SurfaceDrawer.tsx
-var import_react5 = require("react");
-var import_react_native5 = require("react-native");
-var import_react_native_svg2 = __toESM(require("react-native-svg"));
-var import_core2 = require("@ateam-ai-mobile/core");
+// src/api/plugins.ts
+function supportsNative(manifest) {
+  const mode = manifest.render?.mode;
+  return mode === "react-native" || mode === "adaptive";
+}
+function getNativeComponentId(manifest) {
+  if (manifest.render?.mode === "react-native") return manifest.render.component;
+  if (manifest.render?.mode === "adaptive") return manifest.render.reactNative?.component;
+  return null;
+}
+function getNativeBundleUrl(manifest) {
+  const direct = manifest.bundleUrl;
+  if (direct) return direct;
+  const render = manifest.render;
+  if (render.mode === "react-native") return render.bundleUrl || null;
+  if (render.mode === "adaptive") return render.reactNative?.bundleUrl || null;
+  return null;
+}
+function getNativeBundleHash(manifest) {
+  const direct = manifest.bundleHash;
+  if (direct) return direct;
+  const render = manifest.render;
+  if (render.mode === "react-native") return render.bundleHash || null;
+  if (render.mode === "adaptive") return render.reactNative?.bundleHash || null;
+  return null;
+}
+function supportsWebView(manifest) {
+  return manifest.render?.mode === "iframe" || manifest.render?.mode === "adaptive";
+}
+async function listPlugins() {
+  const res = await (0, import_core3.apiFetch)("/mcp", {
+    method: "POST",
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: Date.now(),
+      method: "tools/call",
+      params: {
+        name: "cp.listContextPlugins",
+        arguments: {}
+      }
+    })
+  });
+  const structured = res.result?.structuredContent?.plugins;
+  if (structured) return structured;
+  const text = res.result?.content?.[0]?.text;
+  if (!text) return [];
+  try {
+    const parsed = JSON.parse(text);
+    return parsed.plugins || parsed || [];
+  } catch {
+    return [];
+  }
+}
+async function getPlugin(pluginId) {
+  const res = await (0, import_core3.apiFetch)("/mcp", {
+    method: "POST",
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: Date.now(),
+      method: "tools/call",
+      params: {
+        name: "cp.getContextPlugin",
+        arguments: { id: pluginId }
+        // Backend expects { id }, NOT { pluginId }
+      }
+    })
+  });
+  if (res.result?.structuredContent) return res.result.structuredContent;
+  const text = res.result?.content?.[0]?.text;
+  if (!text) return null;
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed.error) {
+      console.warn("[getPlugin] Backend error:", parsed.error);
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function resolvePluginUrl(manifest, tenant) {
+  const render = manifest.render;
+  let url;
+  if (render?.mode === "iframe") {
+    url = render.iframeUrl;
+  } else if (render?.mode === "adaptive") {
+    url = render.iframeUrl || render.iframe?.iframeUrl;
+  }
+  if (!url) return "";
+  if (url.startsWith("http")) {
+    const sep = url.includes("?") ? "&" : "?";
+    return tenant ? `${url}${sep}tenant=${encodeURIComponent(tenant)}` : url;
+  }
+  if (tenant && url.startsWith("/mcp-ui/")) {
+    const tenantUrl = url.replace("/mcp-ui/", `/mcp-ui/${encodeURIComponent(tenant)}/`);
+    return `${(0, import_core4.getCoreApiUrl)()}${tenantUrl}`;
+  }
+  return `${(0, import_core4.getCoreApiUrl)()}${url}`;
+}
+var import_core3, import_core4;
+var init_plugins = __esm({
+  "src/api/plugins.ts"() {
+    "use strict";
+    import_core3 = require("@ateam-ai-mobile/core");
+    import_core4 = require("@ateam-ai-mobile/core");
+  }
+});
 
 // src/surfaces/AdaOrb.tsx
-var import_react4 = require("react");
-var import_react_native4 = require("react-native");
-var import_react_native_reanimated = __toESM(require("react-native-reanimated"));
-var import_react_native_svg = __toESM(require("react-native-svg"));
-var import_jsx_runtime = require("react/jsx-runtime");
-var AnimatedCircle = import_react_native_reanimated.default.createAnimatedComponent(import_react_native_svg.Circle);
 function AdaOrb({ size = 120, state = "idle", inscription = true }) {
   const showInscription = inscription && size >= 60;
   const center = size / 2;
@@ -649,7 +1403,7 @@ function AdaOrb({ size = 120, state = "idle", inscription = true }) {
   const orbit2 = (0, import_react_native_reanimated.useSharedValue)(0);
   const orbit3 = (0, import_react_native_reanimated.useSharedValue)(0);
   const beat = (0, import_react_native_reanimated.useSharedValue)(1);
-  (0, import_react4.useEffect)(() => {
+  (0, import_react5.useEffect)(() => {
     (0, import_react_native_reanimated.cancelAnimation)(coreScale);
     (0, import_react_native_reanimated.cancelAnimation)(innerScale);
     (0, import_react_native_reanimated.cancelAnimation)(outerScale);
@@ -799,29 +1553,29 @@ function AdaOrb({ size = 120, state = "idle", inscription = true }) {
       opacity: state === "thinking" ? 0.7 : 0
     };
   });
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native4.View, { style: [styles2.wrap, { width: size, height: size }], children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react_native_svg.default, { width: size, height: size, children: [
-    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react_native_svg.Defs, { children: [
-      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react_native_svg.RadialGradient, { id: "adaCore", cx: "36%", cy: "30%", r: "70%", children: [
-        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native_svg.Stop, { offset: "0%", stopColor: "#FFE0B0", stopOpacity: "1" }),
-        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native_svg.Stop, { offset: "28%", stopColor: "#FFA85A", stopOpacity: "1" }),
-        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native_svg.Stop, { offset: "65%", stopColor: "#FF7A28", stopOpacity: "1" }),
-        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native_svg.Stop, { offset: "100%", stopColor: "#B8410A", stopOpacity: "1" })
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native4.View, { style: [styles2.wrap, { width: size, height: size }], children: /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_native_svg.default, { width: size, height: size, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_native_svg.Defs, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_native_svg.RadialGradient, { id: "adaCore", cx: "36%", cy: "30%", r: "70%", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native_svg.Stop, { offset: "0%", stopColor: "#FFE0B0", stopOpacity: "1" }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native_svg.Stop, { offset: "28%", stopColor: "#FFA85A", stopOpacity: "1" }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native_svg.Stop, { offset: "65%", stopColor: "#FF7A28", stopOpacity: "1" }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native_svg.Stop, { offset: "100%", stopColor: "#B8410A", stopOpacity: "1" })
       ] }),
-      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react_native_svg.RadialGradient, { id: "adaInner", cx: "50%", cy: "50%", r: "50%", children: [
-        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native_svg.Stop, { offset: "0%", stopColor: "#FF8A3C", stopOpacity: "0.55" }),
-        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native_svg.Stop, { offset: "100%", stopColor: "#FF7028", stopOpacity: "0" })
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_native_svg.RadialGradient, { id: "adaInner", cx: "50%", cy: "50%", r: "50%", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native_svg.Stop, { offset: "0%", stopColor: "#FF8A3C", stopOpacity: "0.55" }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native_svg.Stop, { offset: "100%", stopColor: "#FF7028", stopOpacity: "0" })
       ] }),
-      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react_native_svg.RadialGradient, { id: "adaOuter", cx: "50%", cy: "50%", r: "50%", children: [
-        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native_svg.Stop, { offset: "0%", stopColor: "#FF7A28", stopOpacity: "0.4" }),
-        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native_svg.Stop, { offset: "100%", stopColor: "#FF6018", stopOpacity: "0" })
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_native_svg.RadialGradient, { id: "adaOuter", cx: "50%", cy: "50%", r: "50%", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native_svg.Stop, { offset: "0%", stopColor: "#FF7A28", stopOpacity: "0.4" }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native_svg.Stop, { offset: "100%", stopColor: "#FF6018", stopOpacity: "0" })
       ] }),
-      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react_native_svg.RadialGradient, { id: "adaSpark", cx: "50%", cy: "50%", r: "50%", children: [
-        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native_svg.Stop, { offset: "0%", stopColor: "#FFFAEB", stopOpacity: "1" }),
-        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native_svg.Stop, { offset: "60%", stopColor: "#FFD095", stopOpacity: "0.9" }),
-        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native_svg.Stop, { offset: "100%", stopColor: "#FFA85A", stopOpacity: "0" })
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_native_svg.RadialGradient, { id: "adaSpark", cx: "50%", cy: "50%", r: "50%", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native_svg.Stop, { offset: "0%", stopColor: "#FFFAEB", stopOpacity: "1" }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native_svg.Stop, { offset: "60%", stopColor: "#FFD095", stopOpacity: "0.9" }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native_svg.Stop, { offset: "100%", stopColor: "#FFA85A", stopOpacity: "0" })
       ] })
     ] }),
-    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
       AnimatedCircle,
       {
         cx: center,
@@ -832,7 +1586,7 @@ function AdaOrb({ size = 120, state = "idle", inscription = true }) {
         animatedProps: ripple1Props
       }
     ),
-    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
       AnimatedCircle,
       {
         cx: center,
@@ -843,7 +1597,7 @@ function AdaOrb({ size = 120, state = "idle", inscription = true }) {
         animatedProps: ripple2Props
       }
     ),
-    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
       AnimatedCircle,
       {
         cx: center,
@@ -854,10 +1608,10 @@ function AdaOrb({ size = 120, state = "idle", inscription = true }) {
         animatedProps: ripple3Props
       }
     ),
-    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AnimatedCircle, { cx: center, cy: center, fill: "url(#adaOuter)", animatedProps: outerProps }),
-    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AnimatedCircle, { cx: center, cy: center, fill: "url(#adaInner)", animatedProps: innerProps }),
-    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AnimatedCircle, { cx: center, cy: center, fill: "url(#adaCore)", animatedProps: coreProps }),
-    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(AnimatedCircle, { cx: center, cy: center, fill: "url(#adaOuter)", animatedProps: outerProps }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(AnimatedCircle, { cx: center, cy: center, fill: "url(#adaInner)", animatedProps: innerProps }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(AnimatedCircle, { cx: center, cy: center, fill: "url(#adaCore)", animatedProps: coreProps }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
       AnimatedCircle,
       {
         r: Math.max(3, size * 0.05),
@@ -865,7 +1619,7 @@ function AdaOrb({ size = 120, state = "idle", inscription = true }) {
         animatedProps: spark1Props
       }
     ),
-    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
       AnimatedCircle,
       {
         r: Math.max(2.5, size * 0.04),
@@ -873,7 +1627,7 @@ function AdaOrb({ size = 120, state = "idle", inscription = true }) {
         animatedProps: spark2Props
       }
     ),
-    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
       AnimatedCircle,
       {
         r: Math.max(2, size * 0.032),
@@ -881,7 +1635,7 @@ function AdaOrb({ size = 120, state = "idle", inscription = true }) {
         animatedProps: spark3Props
       }
     ),
-    showInscription && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    showInscription && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
       import_react_native_svg.Text,
       {
         x: center,
@@ -896,17 +1650,26 @@ function AdaOrb({ size = 120, state = "idle", inscription = true }) {
     )
   ] }) });
 }
-var styles2 = import_react_native4.StyleSheet.create({
-  wrap: {
-    alignItems: "center",
-    justifyContent: "center"
+var import_react5, import_react_native4, import_react_native_reanimated, import_react_native_svg, import_jsx_runtime2, AnimatedCircle, styles2;
+var init_AdaOrb = __esm({
+  "src/surfaces/AdaOrb.tsx"() {
+    "use strict";
+    import_react5 = require("react");
+    import_react_native4 = require("react-native");
+    import_react_native_reanimated = __toESM(require("react-native-reanimated"));
+    import_react_native_svg = __toESM(require("react-native-svg"));
+    import_jsx_runtime2 = require("react/jsx-runtime");
+    AnimatedCircle = import_react_native_reanimated.default.createAnimatedComponent(import_react_native_svg.Circle);
+    styles2 = import_react_native4.StyleSheet.create({
+      wrap: {
+        alignItems: "center",
+        justifyContent: "center"
+      }
+    });
   }
 });
 
 // src/surfaces/SurfaceDrawer.tsx
-var import_jsx_runtime2 = require("react/jsx-runtime");
-var SCREEN_H = import_react_native5.Dimensions.get("window").height;
-var fontFam = import_react_native5.Platform.OS === "ios" ? "SF Pro Rounded" : void 0;
 function SurfaceDrawer({
   visible,
   onClose,
@@ -918,9 +1681,9 @@ function SurfaceDrawer({
   children
 }) {
   const sheetH = Math.round(SCREEN_H * heightRatio);
-  const fadeAnim = (0, import_react5.useRef)(new import_react_native5.Animated.Value(0)).current;
-  const slideAnim = (0, import_react5.useRef)(new import_react_native5.Animated.Value(sheetH)).current;
-  (0, import_react5.useEffect)(() => {
+  const fadeAnim = (0, import_react6.useRef)(new import_react_native5.Animated.Value(0)).current;
+  const slideAnim = (0, import_react6.useRef)(new import_react_native5.Animated.Value(sheetH)).current;
+  (0, import_react6.useEffect)(() => {
     if (visible) {
       import_react_native5.Animated.parallel([
         import_react_native5.Animated.timing(fadeAnim, { toValue: 1, duration: 220, useNativeDriver: true }),
@@ -938,9 +1701,9 @@ function SurfaceDrawer({
     ]).start(() => onClose());
   };
   if (!visible) return null;
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_native5.Animated.View, { style: [styles3.overlay, { opacity: fadeAnim }], pointerEvents: "auto", children: [
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native5.Pressable, { style: import_react_native5.StyleSheet.absoluteFill, onPress: close }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_react_native5.Animated.View, { style: [styles3.overlay, { opacity: fadeAnim }], pointerEvents: "auto", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native5.Pressable, { style: import_react_native5.StyleSheet.absoluteFill, onPress: close }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
       import_react_native5.Animated.View,
       {
         style: [
@@ -948,21 +1711,21 @@ function SurfaceDrawer({
           { height: sheetH, transform: [{ translateY: slideAnim }] }
         ],
         children: [
-          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native5.View, { style: styles3.handle }),
-          /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_native5.View, { style: styles3.header, children: [
-            showOrb ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native5.View, { style: styles3.headerOrb, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(AdaOrb, { size: 36, state: "idle" }) }) : null,
-            /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_native5.View, { style: { flex: 1 }, children: [
-              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native5.Text, { style: styles3.title, children: title }),
-              subtitle ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native5.Text, { style: styles3.subtitle, children: subtitle }) : null,
-              privacy ? /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_native5.View, { style: styles3.privacyPill, children: [
-                /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_native_svg2.default, { width: 11, height: 11, viewBox: "0 0 24 24", fill: "none", stroke: import_core2.ada.inkSoft, strokeWidth: 2.5, strokeLinecap: "round", strokeLinejoin: "round", children: [
-                  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native_svg2.Path, { d: "M19 11H5a2 2 0 00-2 2v7a2 2 0 002 2h14a2 2 0 002-2v-7a2 2 0 00-2-2z" }),
-                  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native_svg2.Path, { d: "M7 11V7a5 5 0 0110 0v4" })
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native5.View, { style: styles3.handle }),
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_react_native5.View, { style: styles3.header, children: [
+            showOrb ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native5.View, { style: styles3.headerOrb, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(AdaOrb, { size: 36, state: "idle" }) }) : null,
+            /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_react_native5.View, { style: { flex: 1 }, children: [
+              /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native5.Text, { style: styles3.title, children: title }),
+              subtitle ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native5.Text, { style: styles3.subtitle, children: subtitle }) : null,
+              privacy ? /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_react_native5.View, { style: styles3.privacyPill, children: [
+                /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_react_native_svg2.default, { width: 11, height: 11, viewBox: "0 0 24 24", fill: "none", stroke: import_core5.ada.inkSoft, strokeWidth: 2.5, strokeLinecap: "round", strokeLinejoin: "round", children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native_svg2.Path, { d: "M19 11H5a2 2 0 00-2 2v7a2 2 0 002 2h14a2 2 0 002-2v-7a2 2 0 00-2-2z" }),
+                  /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native_svg2.Path, { d: "M7 11V7a5 5 0 0110 0v4" })
                 ] }),
-                /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native5.Text, { style: styles3.privacyText, children: "Only you can see this" })
+                /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native5.Text, { style: styles3.privacyText, children: "Only you can see this" })
               ] }) : null
             ] }),
-            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
               import_react_native5.Pressable,
               {
                 accessibilityRole: "button",
@@ -970,105 +1733,115 @@ function SurfaceDrawer({
                 style: styles3.closeBtn,
                 onPress: close,
                 hitSlop: 12,
-                children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native_svg2.default, { width: 18, height: 18, viewBox: "0 0 24 24", fill: "none", stroke: import_core2.ada.inkSoft, strokeWidth: 2.2, strokeLinecap: "round", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native_svg2.Path, { d: "M18 6L6 18M6 6l12 12" }) })
+                children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native_svg2.default, { width: 18, height: 18, viewBox: "0 0 24 24", fill: "none", stroke: import_core5.ada.inkSoft, strokeWidth: 2.2, strokeLinecap: "round", children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native_svg2.Path, { d: "M18 6L6 18M6 6l12 12" }) })
               }
             )
           ] }),
-          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native5.View, { style: styles3.body, children })
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native5.View, { style: styles3.body, children })
         ]
       }
     )
   ] });
 }
-var styles3 = import_react_native5.StyleSheet.create({
-  overlay: {
-    position: "absolute",
-    top: 0,
-    left: 0,
-    right: 0,
-    bottom: 0,
-    backgroundColor: "rgba(26, 20, 16, 0.35)",
-    justifyContent: "flex-end",
-    zIndex: 999,
-    elevation: 999
-  },
-  sheet: {
-    backgroundColor: import_core2.ada.paper,
-    borderTopLeftRadius: 28,
-    borderTopRightRadius: 28,
-    overflow: "hidden"
-  },
-  handle: {
-    width: 40,
-    height: 4,
-    borderRadius: 2,
-    backgroundColor: import_core2.ada.inkMuted,
-    opacity: 0.3,
-    alignSelf: "center",
-    marginTop: 10,
-    marginBottom: 6
-  },
-  header: {
-    flexDirection: "row",
-    alignItems: "center",
-    paddingHorizontal: 22,
-    paddingVertical: 16,
-    gap: 12,
-    borderBottomWidth: 1,
-    borderBottomColor: import_core2.ada.border
-  },
-  headerOrb: {
-    width: 36,
-    height: 36,
-    alignItems: "center",
-    justifyContent: "center"
-  },
-  title: {
-    fontSize: 17,
-    fontWeight: "600",
-    color: import_core2.ada.ink,
-    letterSpacing: -0.2,
-    fontFamily: fontFam
-  },
-  subtitle: {
-    fontSize: 13,
-    fontWeight: "400",
-    color: import_core2.ada.inkSoft,
-    marginTop: 2,
-    letterSpacing: -0.1,
-    fontFamily: fontFam
-  },
-  privacyPill: {
-    flexDirection: "row",
-    alignItems: "center",
-    gap: 5,
-    marginTop: 4
-  },
-  privacyText: {
-    fontSize: 11,
-    fontWeight: "500",
-    color: import_core2.ada.inkSoft,
-    letterSpacing: 0.2,
-    fontFamily: fontFam
-  },
-  closeBtn: {
-    width: 32,
-    height: 32,
-    borderRadius: 16,
-    backgroundColor: import_core2.ada.paperSoft,
-    justifyContent: "center",
-    alignItems: "center"
-  },
-  body: {
-    flex: 1
+var import_react6, import_react_native5, import_react_native_svg2, import_core5, import_jsx_runtime3, SCREEN_H, fontFam, styles3;
+var init_SurfaceDrawer = __esm({
+  "src/surfaces/SurfaceDrawer.tsx"() {
+    "use strict";
+    import_react6 = require("react");
+    import_react_native5 = require("react-native");
+    import_react_native_svg2 = __toESM(require("react-native-svg"));
+    import_core5 = require("@ateam-ai-mobile/core");
+    init_AdaOrb();
+    import_jsx_runtime3 = require("react/jsx-runtime");
+    SCREEN_H = import_react_native5.Dimensions.get("window").height;
+    fontFam = import_react_native5.Platform.OS === "ios" ? "SF Pro Rounded" : void 0;
+    styles3 = import_react_native5.StyleSheet.create({
+      overlay: {
+        position: "absolute",
+        top: 0,
+        left: 0,
+        right: 0,
+        bottom: 0,
+        backgroundColor: "rgba(26, 20, 16, 0.35)",
+        justifyContent: "flex-end",
+        zIndex: 999,
+        elevation: 999
+      },
+      sheet: {
+        backgroundColor: import_core5.ada.paper,
+        borderTopLeftRadius: 28,
+        borderTopRightRadius: 28,
+        overflow: "hidden"
+      },
+      handle: {
+        width: 40,
+        height: 4,
+        borderRadius: 2,
+        backgroundColor: import_core5.ada.inkMuted,
+        opacity: 0.3,
+        alignSelf: "center",
+        marginTop: 10,
+        marginBottom: 6
+      },
+      header: {
+        flexDirection: "row",
+        alignItems: "center",
+        paddingHorizontal: 22,
+        paddingVertical: 16,
+        gap: 12,
+        borderBottomWidth: 1,
+        borderBottomColor: import_core5.ada.border
+      },
+      headerOrb: {
+        width: 36,
+        height: 36,
+        alignItems: "center",
+        justifyContent: "center"
+      },
+      title: {
+        fontSize: 17,
+        fontWeight: "600",
+        color: import_core5.ada.ink,
+        letterSpacing: -0.2,
+        fontFamily: fontFam
+      },
+      subtitle: {
+        fontSize: 13,
+        fontWeight: "400",
+        color: import_core5.ada.inkSoft,
+        marginTop: 2,
+        letterSpacing: -0.1,
+        fontFamily: fontFam
+      },
+      privacyPill: {
+        flexDirection: "row",
+        alignItems: "center",
+        gap: 5,
+        marginTop: 4
+      },
+      privacyText: {
+        fontSize: 11,
+        fontWeight: "500",
+        color: import_core5.ada.inkSoft,
+        letterSpacing: 0.2,
+        fontFamily: fontFam
+      },
+      closeBtn: {
+        width: 32,
+        height: 32,
+        borderRadius: 16,
+        backgroundColor: import_core5.ada.paperSoft,
+        justifyContent: "center",
+        alignItems: "center"
+      },
+      body: {
+        flex: 1
+      }
+    });
   }
 });
 
 // src/surfaces/SurfaceCard.tsx
-var import_react_native6 = require("react-native");
-var import_core3 = require("@ateam-ai-mobile/core");
-var import_jsx_runtime3 = require("react/jsx-runtime");
-var fontFam2 = import_react_native6.Platform.OS === "ios" ? "SF Pro Rounded" : void 0;
 function SurfaceCard({
   icon,
   title,
@@ -1089,7 +1862,7 @@ function SurfaceCard({
     getHaptics()?.impact("medium");
     onLongPress();
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
     import_react_native6.Pressable,
     {
       accessibilityRole: "button",
@@ -1100,71 +1873,76 @@ function SurfaceCard({
       onLongPress: onLongPress ? handleLongPress : void 0,
       disabled: !onPress && !onLongPress,
       children: [
-        /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_react_native6.View, { style: styles4.row, children: [
-          icon ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native6.Text, { style: styles4.icon, children: icon }) : null,
-          /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_react_native6.View, { style: { flex: 1 }, children: [
-            /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native6.Text, { style: styles4.title, children: title }),
-            subtitle ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native6.Text, { style: styles4.subtitle, children: subtitle }) : null
+        /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_react_native6.View, { style: styles4.row, children: [
+          icon ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native6.Text, { style: styles4.icon, children: icon }) : null,
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_react_native6.View, { style: { flex: 1 }, children: [
+            /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native6.Text, { style: styles4.title, children: title }),
+            subtitle ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native6.Text, { style: styles4.subtitle, children: subtitle }) : null
           ] }),
-          arrow ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native6.Text, { style: styles4.arrow, children: "\u2192" }) : null
+          arrow ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native6.Text, { style: styles4.arrow, children: "\u2192" }) : null
         ] }),
-        children ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native6.View, { style: styles4.body, children }) : null
+        children ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native6.View, { style: styles4.body, children }) : null
       ]
     }
   );
 }
-var styles4 = import_react_native6.StyleSheet.create({
-  card: {
-    backgroundColor: import_core3.ada.paperSoft,
-    borderWidth: 1,
-    borderColor: import_core3.ada.border,
-    borderRadius: import_core3.borderRadius.xl,
-    paddingHorizontal: 16,
-    paddingVertical: 14
-  },
-  row: {
-    flexDirection: "row",
-    alignItems: "center",
-    gap: 14
-  },
-  icon: {
-    fontSize: 22
-  },
-  title: {
-    fontSize: 15,
-    fontWeight: "600",
-    color: import_core3.ada.ink,
-    letterSpacing: -0.2,
-    fontFamily: fontFam2
-  },
-  subtitle: {
-    fontSize: 13,
-    fontWeight: "400",
-    color: import_core3.ada.inkMuted,
-    marginTop: 2,
-    letterSpacing: -0.1,
-    fontFamily: fontFam2
-  },
-  arrow: {
-    fontSize: 18,
-    color: import_core3.ada.inkMuted,
-    fontWeight: "400"
-  },
-  body: {
-    marginTop: 10,
-    paddingTop: 10,
-    borderTopWidth: 1,
-    borderTopColor: import_core3.ada.border
+var import_react_native6, import_core6, import_jsx_runtime4, fontFam2, styles4;
+var init_SurfaceCard = __esm({
+  "src/surfaces/SurfaceCard.tsx"() {
+    "use strict";
+    import_react_native6 = require("react-native");
+    init_host();
+    import_core6 = require("@ateam-ai-mobile/core");
+    import_jsx_runtime4 = require("react/jsx-runtime");
+    fontFam2 = import_react_native6.Platform.OS === "ios" ? "SF Pro Rounded" : void 0;
+    styles4 = import_react_native6.StyleSheet.create({
+      card: {
+        backgroundColor: import_core6.ada.paperSoft,
+        borderWidth: 1,
+        borderColor: import_core6.ada.border,
+        borderRadius: import_core6.borderRadius.xl,
+        paddingHorizontal: 16,
+        paddingVertical: 14
+      },
+      row: {
+        flexDirection: "row",
+        alignItems: "center",
+        gap: 14
+      },
+      icon: {
+        fontSize: 22
+      },
+      title: {
+        fontSize: 15,
+        fontWeight: "600",
+        color: import_core6.ada.ink,
+        letterSpacing: -0.2,
+        fontFamily: fontFam2
+      },
+      subtitle: {
+        fontSize: 13,
+        fontWeight: "400",
+        color: import_core6.ada.inkMuted,
+        marginTop: 2,
+        letterSpacing: -0.1,
+        fontFamily: fontFam2
+      },
+      arrow: {
+        fontSize: 18,
+        color: import_core6.ada.inkMuted,
+        fontWeight: "400"
+      },
+      body: {
+        marginTop: 10,
+        paddingTop: 10,
+        borderTopWidth: 1,
+        borderTopColor: import_core6.ada.border
+      }
+    });
   }
 });
 
 // src/surfaces/SurfaceFullscreen.tsx
-var import_react6 = require("react");
-var import_react_native7 = require("react-native");
-var import_react_native_svg3 = __toESM(require("react-native-svg"));
-var import_core4 = require("@ateam-ai-mobile/core");
-var import_jsx_runtime4 = require("react/jsx-runtime");
-var fontFam3 = import_react_native7.Platform.OS === "ios" ? "SF Pro Rounded" : void 0;
 function SurfaceFullscreen({
   visible,
   onClose,
@@ -1175,9 +1953,9 @@ function SurfaceFullscreen({
   closeIcon = "x",
   closeLabel = "Close"
 }) {
-  const fadeAnim = (0, import_react6.useRef)(new import_react_native7.Animated.Value(0)).current;
-  const heroScale = (0, import_react6.useRef)(new import_react_native7.Animated.Value(0.6)).current;
-  (0, import_react6.useEffect)(() => {
+  const fadeAnim = (0, import_react7.useRef)(new import_react_native7.Animated.Value(0)).current;
+  const heroScale = (0, import_react7.useRef)(new import_react_native7.Animated.Value(0.6)).current;
+  (0, import_react7.useEffect)(() => {
     if (visible) {
       import_react_native7.Animated.parallel([
         import_react_native7.Animated.timing(fadeAnim, { toValue: 1, duration: 280, useNativeDriver: true }),
@@ -1197,22 +1975,22 @@ function SurfaceFullscreen({
   if (!visible) return null;
   const renderCloseIcon = () => {
     if (closeIcon === "hangup") {
-      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native_svg3.default, { width: 22, height: 22, viewBox: "0 0 24 24", fill: import_core4.ada.paper, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native_svg3.Path, { d: "M3.68 16.07l3.92-3.11c.28-.23.68-.28 1.01-.14l2.77 1.15c.36.15.61.5.61.89v2.82c4.34-.76 7.93-4.35 8.69-8.69h-2.82c-.39 0-.74-.25-.89-.61L16.12 5.6c-.13-.33-.09-.73.14-1.01l3.11-3.92c.29-.37.81-.41 1.15-.08l3.24 3.24c.2.2.31.47.31.76C24 14.44 14.44 24 4.59 24c-.29 0-.56-.11-.76-.31L.59 20.45c-.33-.34-.29-.86.09-1.15z" }) });
+      return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_native_svg3.default, { width: 22, height: 22, viewBox: "0 0 24 24", fill: import_core7.ada.paper, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_native_svg3.Path, { d: "M3.68 16.07l3.92-3.11c.28-.23.68-.28 1.01-.14l2.77 1.15c.36.15.61.5.61.89v2.82c4.34-.76 7.93-4.35 8.69-8.69h-2.82c-.39 0-.74-.25-.89-.61L16.12 5.6c-.13-.33-.09-.73.14-1.01l3.11-3.92c.29-.37.81-.41 1.15-.08l3.24 3.24c.2.2.31.47.31.76C24 14.44 14.44 24 4.59 24c-.29 0-.56-.11-.76-.31L.59 20.45c-.33-.34-.29-.86.09-1.15z" }) });
     }
     if (closeIcon === "x") {
-      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native_svg3.default, { width: 20, height: 20, viewBox: "0 0 24 24", fill: "none", stroke: import_core4.ada.paper, strokeWidth: 2.5, strokeLinecap: "round", children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native_svg3.Path, { d: "M18 6L6 18M6 6l12 12" }) });
+      return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_native_svg3.default, { width: 20, height: 20, viewBox: "0 0 24 24", fill: "none", stroke: import_core7.ada.paper, strokeWidth: 2.5, strokeLinecap: "round", children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_native_svg3.Path, { d: "M18 6L6 18M6 6l12 12" }) });
     }
     return closeIcon;
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_react_native7.Animated.View, { style: [styles5.overlay, { opacity: fadeAnim }], pointerEvents: "auto", children: [
-    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_react_native7.View, { style: styles5.topBar, children: [
-      showWordmark ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native7.Text, { style: styles5.wordmark, children: "ada" }) : null,
-      status ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native7.Text, { style: styles5.status, children: status }) : null
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_react_native7.Animated.View, { style: [styles5.overlay, { opacity: fadeAnim }], pointerEvents: "auto", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_react_native7.View, { style: styles5.topBar, children: [
+      showWordmark ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_native7.Text, { style: styles5.wordmark, children: "ada" }) : null,
+      status ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_native7.Text, { style: styles5.status, children: status }) : null
     ] }),
-    hero ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native7.View, { style: styles5.heroWrap, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native7.Animated.View, { style: { transform: [{ scale: heroScale }] }, children: hero }) }) : null,
-    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native7.View, { style: styles5.body, children }),
-    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_react_native7.View, { style: styles5.bottomBar, children: [
-      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+    hero ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_native7.View, { style: styles5.heroWrap, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_native7.Animated.View, { style: { transform: [{ scale: heroScale }] }, children: hero }) }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_native7.View, { style: styles5.body, children }),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_react_native7.View, { style: styles5.bottomBar, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
         import_react_native7.Pressable,
         {
           accessibilityRole: "button",
@@ -1223,151 +2001,166 @@ function SurfaceFullscreen({
           children: renderCloseIcon()
         }
       ),
-      closeLabel ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native7.Text, { style: styles5.closeLabel, children: closeLabel }) : null
+      closeLabel ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react_native7.Text, { style: styles5.closeLabel, children: closeLabel }) : null
     ] })
   ] });
 }
-var styles5 = import_react_native7.StyleSheet.create({
-  overlay: {
-    position: "absolute",
-    top: 0,
-    left: 0,
-    right: 0,
-    bottom: 0,
-    backgroundColor: import_core4.ada.paper,
-    zIndex: 1e3,
-    elevation: 1e3
-  },
-  topBar: {
-    paddingTop: import_react_native7.Platform.OS === "ios" ? 64 : 36,
-    paddingHorizontal: 24,
-    alignItems: "center",
-    gap: 6
-  },
-  wordmark: {
-    fontSize: 14,
-    fontFamily: fontFam3,
-    fontWeight: "500",
-    color: import_core4.ada.inkMuted,
-    letterSpacing: 4
-  },
-  status: {
-    fontSize: 17,
-    fontFamily: fontFam3,
-    fontWeight: "500",
-    color: import_core4.ada.ink,
-    letterSpacing: -0.2
-  },
-  heroWrap: {
-    paddingTop: 24,
-    paddingBottom: 12,
-    alignItems: "center",
-    justifyContent: "center"
-  },
-  body: {
-    flex: 1
-  },
-  bottomBar: {
-    paddingBottom: import_react_native7.Platform.OS === "ios" ? 48 : 32,
-    paddingTop: 12,
-    alignItems: "center",
-    gap: 8
-  },
-  closeBtn: {
-    width: 64,
-    height: 64,
-    borderRadius: 32,
-    backgroundColor: import_core4.ada.ink,
-    justifyContent: "center",
-    alignItems: "center",
-    shadowColor: import_core4.ada.ink,
-    shadowOffset: { width: 0, height: 8 },
-    shadowOpacity: 0.18,
-    shadowRadius: 14,
-    elevation: 8
-  },
-  closeLabel: {
-    fontSize: 13,
-    fontFamily: fontFam3,
-    fontWeight: "500",
-    color: import_core4.ada.inkMuted,
-    letterSpacing: 0.3
+var import_react7, import_react_native7, import_react_native_svg3, import_core7, import_jsx_runtime5, fontFam3, styles5;
+var init_SurfaceFullscreen = __esm({
+  "src/surfaces/SurfaceFullscreen.tsx"() {
+    "use strict";
+    import_react7 = require("react");
+    import_react_native7 = require("react-native");
+    import_react_native_svg3 = __toESM(require("react-native-svg"));
+    import_core7 = require("@ateam-ai-mobile/core");
+    import_jsx_runtime5 = require("react/jsx-runtime");
+    fontFam3 = import_react_native7.Platform.OS === "ios" ? "SF Pro Rounded" : void 0;
+    styles5 = import_react_native7.StyleSheet.create({
+      overlay: {
+        position: "absolute",
+        top: 0,
+        left: 0,
+        right: 0,
+        bottom: 0,
+        backgroundColor: import_core7.ada.paper,
+        zIndex: 1e3,
+        elevation: 1e3
+      },
+      topBar: {
+        paddingTop: import_react_native7.Platform.OS === "ios" ? 64 : 36,
+        paddingHorizontal: 24,
+        alignItems: "center",
+        gap: 6
+      },
+      wordmark: {
+        fontSize: 14,
+        fontFamily: fontFam3,
+        fontWeight: "500",
+        color: import_core7.ada.inkMuted,
+        letterSpacing: 4
+      },
+      status: {
+        fontSize: 17,
+        fontFamily: fontFam3,
+        fontWeight: "500",
+        color: import_core7.ada.ink,
+        letterSpacing: -0.2
+      },
+      heroWrap: {
+        paddingTop: 24,
+        paddingBottom: 12,
+        alignItems: "center",
+        justifyContent: "center"
+      },
+      body: {
+        flex: 1
+      },
+      bottomBar: {
+        paddingBottom: import_react_native7.Platform.OS === "ios" ? 48 : 32,
+        paddingTop: 12,
+        alignItems: "center",
+        gap: 8
+      },
+      closeBtn: {
+        width: 64,
+        height: 64,
+        borderRadius: 32,
+        backgroundColor: import_core7.ada.ink,
+        justifyContent: "center",
+        alignItems: "center",
+        shadowColor: import_core7.ada.ink,
+        shadowOffset: { width: 0, height: 8 },
+        shadowOpacity: 0.18,
+        shadowRadius: 14,
+        elevation: 8
+      },
+      closeLabel: {
+        fontSize: 13,
+        fontFamily: fontFam3,
+        fontWeight: "500",
+        color: import_core7.ada.inkMuted,
+        letterSpacing: 0.3
+      }
+    });
   }
 });
 
 // src/registry/store.ts
-var import_zustand = require("zustand");
-var useSurfaceStore = (0, import_zustand.create)((set, get) => ({
-  manifests: {},
-  activeDrawer: null,
-  activeFullscreen: null,
-  activeProps: {},
-  mountKey: 0,
-  register: (manifest) => set((s) => ({ manifests: { ...s.manifests, [manifest.id]: manifest } })),
-  unregister: (id) => set((s) => {
-    const next = { ...s.manifests };
-    delete next[id];
-    const nextProps = { ...s.activeProps };
-    delete nextProps[id];
-    return { manifests: next, activeProps: nextProps };
-  }),
-  show: (id, props) => {
-    const m = get().manifests[id];
-    if (!m) {
-      console.warn("[SurfaceStore] show: unknown surface id", id);
-      return;
-    }
-    set((s) => {
-      const nextProps = props !== void 0 ? { ...s.activeProps, [id]: props } : s.activeProps;
-      const mountKey = s.mountKey + 1;
-      if (m.type === "drawer") return { activeDrawer: id, activeProps: nextProps, mountKey };
-      if (m.type === "fullscreen") return { activeFullscreen: id, activeProps: nextProps, mountKey };
-      return { mountKey };
-    });
-  },
-  hide: (id) => {
-    const s = get();
-    if (!id) {
-      const cleanup2 = { ...s.activeProps };
-      if (s.activeDrawer) delete cleanup2[s.activeDrawer];
-      if (s.activeFullscreen) delete cleanup2[s.activeFullscreen];
-      set({ activeDrawer: null, activeFullscreen: null, activeProps: cleanup2 });
-      return;
-    }
-    const cleanup = { ...s.activeProps };
-    delete cleanup[id];
-    const patch = { activeProps: cleanup };
-    if (s.activeDrawer === id) patch.activeDrawer = null;
-    if (s.activeFullscreen === id) patch.activeFullscreen = null;
-    set(patch);
-  },
-  list: (filter) => {
-    const all = Object.values(get().manifests);
-    return all.filter((m) => {
-      if (filter?.type && m.type !== filter.type) return false;
-      if (filter?.visibility && !filter.visibility.includes(m.visibility)) return false;
-      if (filter?.placement) {
-        if (filter.placement === "unset") {
-          if (m.placement) return false;
-        } else if (m.placement !== filter.placement) {
-          return false;
-        }
-      }
-      return true;
-    });
-  }
-}));
 function isMountSurface(m) {
   return m.type === "drawer" || m.type === "fullscreen";
 }
 function isInlineSurface(m) {
   return m.type === "card" || m.type === "header" || m.type === "ambient" || m.type === "nudge";
 }
+var import_zustand, useSurfaceStore;
+var init_store = __esm({
+  "src/registry/store.ts"() {
+    "use strict";
+    import_zustand = require("zustand");
+    useSurfaceStore = (0, import_zustand.create)((set, get) => ({
+      manifests: {},
+      activeDrawer: null,
+      activeFullscreen: null,
+      activeProps: {},
+      mountKey: 0,
+      register: (manifest) => set((s) => ({ manifests: { ...s.manifests, [manifest.id]: manifest } })),
+      unregister: (id) => set((s) => {
+        const next = { ...s.manifests };
+        delete next[id];
+        const nextProps = { ...s.activeProps };
+        delete nextProps[id];
+        return { manifests: next, activeProps: nextProps };
+      }),
+      show: (id, props) => {
+        const m = get().manifests[id];
+        if (!m) {
+          console.warn("[SurfaceStore] show: unknown surface id", id);
+          return;
+        }
+        set((s) => {
+          const nextProps = props !== void 0 ? { ...s.activeProps, [id]: props } : s.activeProps;
+          const mountKey = s.mountKey + 1;
+          if (m.type === "drawer") return { activeDrawer: id, activeProps: nextProps, mountKey };
+          if (m.type === "fullscreen") return { activeFullscreen: id, activeProps: nextProps, mountKey };
+          return { mountKey };
+        });
+      },
+      hide: (id) => {
+        const s = get();
+        if (!id) {
+          const cleanup2 = { ...s.activeProps };
+          if (s.activeDrawer) delete cleanup2[s.activeDrawer];
+          if (s.activeFullscreen) delete cleanup2[s.activeFullscreen];
+          set({ activeDrawer: null, activeFullscreen: null, activeProps: cleanup2 });
+          return;
+        }
+        const cleanup = { ...s.activeProps };
+        delete cleanup[id];
+        const patch = { activeProps: cleanup };
+        if (s.activeDrawer === id) patch.activeDrawer = null;
+        if (s.activeFullscreen === id) patch.activeFullscreen = null;
+        set(patch);
+      },
+      list: (filter) => {
+        const all = Object.values(get().manifests);
+        return all.filter((m) => {
+          if (filter?.type && m.type !== filter.type) return false;
+          if (filter?.visibility && !filter.visibility.includes(m.visibility)) return false;
+          if (filter?.placement) {
+            if (filter.placement === "unset") {
+              if (m.placement) return false;
+            } else if (m.placement !== filter.placement) {
+              return false;
+            }
+          }
+          return true;
+        });
+      }
+    }));
+  }
+});
 
 // src/registry/SurfaceDispatcher.tsx
-var import_react7 = require("react");
-var import_core5 = require("@ateam-ai-mobile/core");
-var import_jsx_runtime5 = require("react/jsx-runtime");
 function SurfaceDispatcher() {
   const manifests = useSurfaceStore((s) => s.manifests);
   const activeDrawer = useSurfaceStore((s) => s.activeDrawer);
@@ -1375,8 +2168,8 @@ function SurfaceDispatcher() {
   const activeProps = useSurfaceStore((s) => s.activeProps);
   const mountKey = useSurfaceStore((s) => s.mountKey);
   const hide = useSurfaceStore((s) => s.hide);
-  (0, import_react7.useEffect)(() => {
-    const unsub = import_core5.pluginCommandEmitter.on("plugin-close", ({ pluginId } = {}) => {
+  (0, import_react8.useEffect)(() => {
+    const unsub = import_core8.pluginCommandEmitter.on("plugin-close", ({ pluginId } = {}) => {
       if (!pluginId) return;
       const s = useSurfaceStore.getState();
       if (s.activeDrawer === pluginId || s.activeFullscreen === pluginId) {
@@ -1389,8 +2182,8 @@ function SurfaceDispatcher() {
   const fullscreen = activeFullscreen ? manifests[activeFullscreen] : null;
   const drawerProps = activeDrawer ? activeProps[activeDrawer] : void 0;
   const fullscreenProps = activeFullscreen ? activeProps[activeFullscreen] : void 0;
-  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_jsx_runtime5.Fragment, { children: [
-    drawer && drawer.type === "drawer" && drawer.Component ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_jsx_runtime6.Fragment, { children: [
+    drawer && drawer.type === "drawer" && drawer.Component ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
       drawer.Component,
       {
         dismiss: () => hide(drawer.id),
@@ -1398,7 +2191,7 @@ function SurfaceDispatcher() {
       },
       `drawer-${drawer.id}-${mountKey}`
     ) : null,
-    fullscreen && fullscreen.type === "fullscreen" && fullscreen.Component ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+    fullscreen && fullscreen.type === "fullscreen" && fullscreen.Component ? /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
       fullscreen.Component,
       {
         dismiss: () => hide(fullscreen.id),
@@ -1408,75 +2201,18 @@ function SurfaceDispatcher() {
     ) : null
   ] });
 }
+var import_react8, import_core8, import_jsx_runtime6;
+var init_SurfaceDispatcher = __esm({
+  "src/registry/SurfaceDispatcher.tsx"() {
+    "use strict";
+    import_react8 = require("react");
+    init_store();
+    import_core8 = require("@ateam-ai-mobile/core");
+    import_jsx_runtime6 = require("react/jsx-runtime");
+  }
+});
 
 // src/utils/sha256.ts
-var K = new Uint32Array([
-  1116352408,
-  1899447441,
-  3049323471,
-  3921009573,
-  961987163,
-  1508970993,
-  2453635748,
-  2870763221,
-  3624381080,
-  310598401,
-  607225278,
-  1426881987,
-  1925078388,
-  2162078206,
-  2614888103,
-  3248222580,
-  3835390401,
-  4022224774,
-  264347078,
-  604807628,
-  770255983,
-  1249150122,
-  1555081692,
-  1996064986,
-  2554220882,
-  2821834349,
-  2952996808,
-  3210313671,
-  3336571891,
-  3584528711,
-  113926993,
-  338241895,
-  666307205,
-  773529912,
-  1294757372,
-  1396182291,
-  1695183700,
-  1986661051,
-  2177026350,
-  2456956037,
-  2730485921,
-  2820302411,
-  3259730800,
-  3345764771,
-  3516065817,
-  3600352804,
-  4094571909,
-  275423344,
-  430227734,
-  506948616,
-  659060556,
-  883997877,
-  958139571,
-  1322822218,
-  1537002063,
-  1747873779,
-  1955562222,
-  2024104815,
-  2227730452,
-  2361852424,
-  2428436474,
-  2756734187,
-  3204031479,
-  3329325298
-]);
-var rotr = (n, x) => x >>> n | x << 32 - n;
 function sha256Hex(message) {
   const utf8 = unescape(encodeURIComponent(message));
   const bytes = new Uint8Array(utf8.length);
@@ -1544,547 +2280,1143 @@ function sha256Hex(message) {
   }
   return out;
 }
-
-// src/bundles/storage.ts
-var MemoryBundleStorage = class {
-  constructor() {
-    this.index = {};
-    this.files = /* @__PURE__ */ new Map();
-  }
-  async loadIndex() {
-    return this.index;
+var K, rotr;
+var init_sha256 = __esm({
+  "src/utils/sha256.ts"() {
+    "use strict";
+    K = new Uint32Array([
+      1116352408,
+      1899447441,
+      3049323471,
+      3921009573,
+      961987163,
+      1508970993,
+      2453635748,
+      2870763221,
+      3624381080,
+      310598401,
+      607225278,
+      1426881987,
+      1925078388,
+      2162078206,
+      2614888103,
+      3248222580,
+      3835390401,
+      4022224774,
+      264347078,
+      604807628,
+      770255983,
+      1249150122,
+      1555081692,
+      1996064986,
+      2554220882,
+      2821834349,
+      2952996808,
+      3210313671,
+      3336571891,
+      3584528711,
+      113926993,
+      338241895,
+      666307205,
+      773529912,
+      1294757372,
+      1396182291,
+      1695183700,
+      1986661051,
+      2177026350,
+      2456956037,
+      2730485921,
+      2820302411,
+      3259730800,
+      3345764771,
+      3516065817,
+      3600352804,
+      4094571909,
+      275423344,
+      430227734,
+      506948616,
+      659060556,
+      883997877,
+      958139571,
+      1322822218,
+      1537002063,
+      1747873779,
+      1955562222,
+      2024104815,
+      2227730452,
+      2361852424,
+      2428436474,
+      2756734187,
+      3204031479,
+      3329325298
+    ]);
+    rotr = (n, x) => x >>> n | x << 32 - n;
   }
-  async saveIndex(index) {
-    this.index = index;
-  }
-  async readBundle(localPath) {
-    return this.files.get(localPath) ?? null;
-  }
-  async writeBundle(key, content) {
-    const localPath = `memory://${key}`;
-    this.files.set(localPath, content);
-    return localPath;
+});
+
+// src/bundles/integrity.ts
+function assertBundleIntegrity(content, verifiedHash, label) {
+  const digest = sha256Hex(content);
+  if (!verifiedHash) {
+    throw new Error(`[bundle-integrity] refusing to evaluate ${label}: no verified SHA-256 (fail closed).`);
   }
-  async deleteBundle(localPath) {
-    this.files.delete(localPath);
+  if (digest !== verifiedHash.toLowerCase()) {
+    throw new Error(
+      `[bundle-integrity] integrity FAIL at eval for ${label}: content sha256 ${digest.slice(0, 12)}\u2026 \u2260 verified ${verifiedHash.slice(0, 12)}\u2026. Refusing to evaluate.`
+    );
   }
-  async clearAll() {
-    this.index = {};
-    this.files.clear();
+}
+var init_integrity = __esm({
+  "src/bundles/integrity.ts"() {
+    "use strict";
+    init_sha256();
   }
-};
-var _storage = new MemoryBundleStorage();
+});
+
+// src/bundles/storage.ts
+function selectOwnedCacheEntries(entries, tenant) {
+  if (!tenant) return [];
+  return (entries || []).filter((e) => !!e && e.tenant === tenant);
+}
 function setBundleStorage(storage) {
   _storage = storage;
 }
 function getBundleStorage() {
   return _storage;
 }
+var MemoryBundleStorage, _storage;
+var init_storage = __esm({
+  "src/bundles/storage.ts"() {
+    "use strict";
+    MemoryBundleStorage = class {
+      constructor() {
+        this.index = {};
+        this.files = /* @__PURE__ */ new Map();
+      }
+      async loadIndex() {
+        return this.index;
+      }
+      async saveIndex(index) {
+        this.index = index;
+      }
+      async readBundle(localPath) {
+        return this.files.get(localPath) ?? null;
+      }
+      async writeBundle(key, content) {
+        const localPath = `memory://${key}`;
+        this.files.set(localPath, content);
+        return localPath;
+      }
+      async deleteBundle(localPath) {
+        this.files.delete(localPath);
+      }
+      async clearAll() {
+        this.index = {};
+        this.files.clear();
+      }
+    };
+    _storage = new MemoryBundleStorage();
+  }
+});
 
 // src/bundles/bundleManager.ts
-var ReactShim = {
-  __esModule: true,
-  default: import_react8.default,
-  ...import_react8.default,
-  // Explicitly include hooks (React 19 may not have them as own enumerable props)
-  useState: import_react9.useState,
-  useEffect: import_react9.useEffect,
-  useCallback: import_react9.useCallback,
-  useMemo: import_react9.useMemo,
-  useRef: import_react9.useRef,
-  useContext: import_react9.useContext,
-  useReducer: import_react9.useReducer,
-  useLayoutEffect: import_react9.useLayoutEffect,
-  useImperativeHandle: import_react9.useImperativeHandle,
-  useDebugValue: import_react9.useDebugValue,
-  createElement: import_react8.default.createElement,
-  Fragment: import_react8.default.Fragment,
-  Component: import_react8.default.Component,
-  PureComponent: import_react8.default.PureComponent,
-  createContext: import_react8.default.createContext,
-  forwardRef: import_react8.default.forwardRef,
-  memo: import_react8.default.memo,
-  Children: import_react8.default.Children,
-  cloneElement: import_react8.default.cloneElement,
-  isValidElement: import_react8.default.isValidElement,
-  createRef: import_react8.default.createRef,
-  lazy: import_react8.default.lazy,
-  Suspense: import_react8.default.Suspense
-};
-var PluginSDKShim = Object.freeze({
-  ...sdk_exports,
-  SurfaceDrawer,
-  SurfaceCard,
-  SurfaceFullscreen,
-  useSurfaceStore,
-  SurfaceDispatcher,
-  PluginSDK: Object.freeze({
-    ...PluginSDK,
-    register: PluginSDK.register
-  }),
-  register
-});
-var requireShim = (name) => {
-  if (name === "react") return ReactShim;
-  if (name === "react-native") return ReactNative;
-  if (name === "@adas/plugin-sdk") return PluginSDKShim;
-  const hostModule = resolveBundleModule(name);
-  if (hostModule !== void 0) return hostModule;
-  console.warn(`[BundleManager] Unknown module: ${name} \u2014 register it via registerBundleModules()`);
-  return {};
-};
-var CACHE_TTL = 7 * 24 * 60 * 60 * 1e3;
-var BundleManager = class {
-  constructor() {
-    /** In-memory module cache: bundleUrl → evaluated module.exports */
-    this.modules = /* @__PURE__ */ new Map();
-    /** In-flight download deduplication: bundleUrl → Promise */
-    this.inflight = /* @__PURE__ */ new Map();
-  }
-  // ── Public API ──────────────────────────────────────────────
-  /**
-   * Load a plugin component. Returns the RegisteredUIPlugin object.
-   * Handles: in-memory cache → disk cache → download → evaluate → extract.
-   *
-   * `expectedHash` (SHA-256 hex from cp.getContextPlugin manifest) MUST be
-   * provided for any bundle the user has not previously verified — without
-   * it, a tampered bundle is `eval`'d as JS with full RN runtime + every
-   * native capability the manifest declares.
-   */
-  async load(pluginId, bundleUrl, version, expectedHash) {
-    const cached = this.getComponentFromMemory(pluginId, bundleUrl);
-    if (cached) return cached;
-    let modulePromise = this.inflight.get(bundleUrl);
-    if (!modulePromise) {
-      modulePromise = this.loadModule(bundleUrl, version, expectedHash);
-      this.inflight.set(bundleUrl, modulePromise);
-      modulePromise.catch(() => {
-      }).finally(() => this.inflight.delete(bundleUrl));
-    }
-    await modulePromise;
-    const component = this.getComponentFromMemory(pluginId, bundleUrl);
-    if (!component) {
-      throw new Error(
-        `Bundle loaded from ${bundleUrl} but no component found for "${pluginId}". Available exports: ${this.describeModule(this.modules.get(bundleUrl))}`
-      );
-    }
-    return component;
-  }
-  /**
-   * Prewarm: load every plugin bundle in the background after app boot, so a
-   * later open is instant (in-memory hit) instead of round-tripping the
-   * network. Errors are swallowed per-plugin — one bad bundle shouldn't
-   * block others. Concurrency capped at 3.
-   */
-  async prewarmAll(items) {
-    const queue = [...items];
-    const concurrency = Math.min(3, queue.length);
-    const start = Date.now();
-    let okCount = 0;
-    let failCount = 0;
-    const worker = async () => {
-      while (queue.length > 0) {
-        const it = queue.shift();
-        if (!it) return;
-        try {
-          await this.load(it.pluginId, it.bundleUrl, it.version, it.bundleHash);
-          okCount++;
-        } catch (err) {
-          failCount++;
-          console.log(`[prewarm] ${it.pluginId}: ${err instanceof Error ? err.message : String(err)}`);
+var import_react9, import_react10, ReactNative, import_core9, ReactShim, PluginSDKShim, requireShim, CACHE_TTL, hasComponent, hasTools, BundleManager, bundleManager;
+var init_bundleManager = __esm({
+  "src/bundles/bundleManager.ts"() {
+    "use strict";
+    import_react9 = __toESM(require("react"));
+    import_react10 = require("react");
+    ReactNative = __toESM(require("react-native"));
+    import_core9 = require("@ateam-ai-mobile/core");
+    init_sdk();
+    init_SurfaceDrawer();
+    init_SurfaceCard();
+    init_SurfaceFullscreen();
+    init_store();
+    init_SurfaceDispatcher();
+    init_host();
+    init_sha256();
+    init_integrity();
+    init_storage();
+    init_registry();
+    ReactShim = {
+      __esModule: true,
+      default: import_react9.default,
+      ...import_react9.default,
+      // Explicitly include hooks (React 19 may not have them as own enumerable props)
+      useState: import_react10.useState,
+      useEffect: import_react10.useEffect,
+      useCallback: import_react10.useCallback,
+      useMemo: import_react10.useMemo,
+      useRef: import_react10.useRef,
+      useContext: import_react10.useContext,
+      useReducer: import_react10.useReducer,
+      useLayoutEffect: import_react10.useLayoutEffect,
+      useImperativeHandle: import_react10.useImperativeHandle,
+      useDebugValue: import_react10.useDebugValue,
+      createElement: import_react9.default.createElement,
+      Fragment: import_react9.default.Fragment,
+      Component: import_react9.default.Component,
+      PureComponent: import_react9.default.PureComponent,
+      createContext: import_react9.default.createContext,
+      forwardRef: import_react9.default.forwardRef,
+      memo: import_react9.default.memo,
+      Children: import_react9.default.Children,
+      cloneElement: import_react9.default.cloneElement,
+      isValidElement: import_react9.default.isValidElement,
+      createRef: import_react9.default.createRef,
+      lazy: import_react9.default.lazy,
+      Suspense: import_react9.default.Suspense
+    };
+    PluginSDKShim = Object.freeze({
+      ...sdk_exports,
+      SurfaceDrawer,
+      SurfaceCard,
+      SurfaceFullscreen,
+      useSurfaceStore,
+      SurfaceDispatcher,
+      PluginSDK: Object.freeze({
+        ...PluginSDK,
+        register: PluginSDK.register
+      }),
+      register
+    });
+    requireShim = (name) => {
+      if (name === "react") return ReactShim;
+      if (name === "react-native") return ReactNative;
+      if (name === "@adas/plugin-sdk") return PluginSDKShim;
+      const hostModule = resolveBundleModule(name);
+      if (hostModule !== void 0) return hostModule;
+      console.warn(`[BundleManager] Unknown module: ${name} \u2014 register it via registerBundleModules()`);
+      return {};
+    };
+    CACHE_TTL = 7 * 24 * 60 * 60 * 1e3;
+    hasComponent = (val) => !!val && typeof val === "object" && typeof val.Component === "function";
+    hasTools = (val) => !!val && typeof val === "object" && Array.isArray(val.tools) && val.tools.length > 0;
+    BundleManager = class {
+      constructor() {
+        /** In-memory module cache: bundleUrl → evaluated module.exports. Holds ONE
+         *  tenant's modules at a time — the tenant boundary is `cacheTenant` /
+         *  `requireTenant()`, NOT the key. */
+        this.modules = /* @__PURE__ */ new Map();
+        /** What is actually RUNNING, keyed by bundleUrl (for the current tenant). See
+         *  getLoadedBundles(). */
+        this.provenance = /* @__PURE__ */ new Map();
+        /** In-flight download deduplication: bundleUrl → Promise */
+        this.inflight = /* @__PURE__ */ new Map();
+        /**
+         * The tenant the in-memory caches (modules / provenance / inflight) currently
+         * belong to. This is the tenant BOUNDARY for evaluated code.
+         *
+         * A bundleUrl resolves PER-TENANT on the server — one url, different bytes for
+         * different tenants — so a memory hit keyed on url alone would hand tenant B
+         * the module tenant A already evaluated and ran. PR #9 scoped the DISK cache
+         * (per-tenant index + hash gate); the in-memory map was left url-keyed. This
+         * closes that: the caches only ever hold ONE tenant's modules, and a switch
+         * drops them before anything is served.
+         */
+        this.cacheTenant = null;
+        /**
+         * pluginIds this manager registered device tools for. A tenant switch drops
+         * the in-memory modules AND unregisters these, so the incoming tenant's bundle
+         * re-registers into a clean registry instead of being refused as a duplicate
+         * of the previous tenant's tools.
+         */
+        this.registeredToolPluginIds = /* @__PURE__ */ new Set();
+        /** bundleUrl → the trusted declaration last recorded on its disk-cache entry
+         *  this session, so a memory hit with unchanged grants skips the index I/O. */
+        this.recordedDeclarations = /* @__PURE__ */ new Map();
+        /**
+         * Enforce the in-memory tenant boundary. Call at the top of every public load
+         * path, BEFORE any cache read.
+         *
+         * FAIL CLOSED: without a tenant identity we cannot prove a cached module is
+         * this session's, so we drop everything and refuse rather than risk serving
+         * one tenant's evaluated code to another. On a tenant change we drop the
+         * previous tenant's modules (and their tool registrations) before proceeding.
+         */
+        /**
+         * Monotonic load generation. Bumped on every in-memory wipe (a tenant change,
+         * fail-closed, or clearAll). A load captures it at ENTRY; a completion whose
+         * generation no longer matches is stale and is discarded before it can commit.
+         * This closes the async race the sequential guard cannot: tenant A's in-flight
+         * loadModule can resolve AFTER a switch to B — clearing `inflight` does not
+         * cancel that Promise — and would otherwise write A's module / provenance /
+         * device tools into the singleton now marked cacheTenant=B.
+         */
+        this.epoch = 0;
+      }
+      requireTenant() {
+        const tenant = (0, import_core9.getTenant)();
+        if (!tenant) {
+          this.dropInMemory();
+          this.cacheTenant = null;
+          throw new Error(
+            "[BundleManager] refusing to load a tenant-scoped bundle without a tenant identity (fail closed)"
+          );
+        }
+        if (tenant !== this.cacheTenant) {
+          this.dropInMemory();
+          this.cacheTenant = tenant;
         }
+        return tenant;
       }
-    };
-    await Promise.all(Array.from({ length: concurrency }, worker));
-    console.log(`[prewarm] ${okCount} loaded, ${failCount} failed in ${Date.now() - start}ms`);
-  }
-  /**
-   * Clear all caches (in-memory + storage).
-   */
-  async clearAll() {
-    this.modules.clear();
-    try {
-      await getBundleStorage().clearAll();
-    } catch (err) {
-      console.warn("[BundleManager] clearAll error:", err);
-    }
-  }
-  /**
-   * Clear cache for a specific plugin/bundle.
-   */
-  async clearPlugin(pluginId) {
-    const storage = getBundleStorage();
-    const index = await storage.loadIndex();
-    const entry = index[pluginId];
-    if (entry) {
-      this.modules.delete(entry.bundleUrl);
-      delete index[pluginId];
-      await storage.saveIndex(index);
-      try {
-        await storage.deleteBundle(entry.localPath);
-      } catch {
+      /** Drop every in-memory cache and unregister the device tools this manager
+       *  registered — used on a tenant change and by clearAll(). */
+      dropInMemory() {
+        for (const pluginId of this.registeredToolPluginIds) {
+          try {
+            unregisterDeviceTools(pluginId);
+          } catch {
+          }
+        }
+        this.registeredToolPluginIds.clear();
+        this.recordedDeclarations.clear();
+        this.modules.clear();
+        this.provenance.clear();
+        this.inflight.clear();
+        this.epoch++;
       }
-    }
-  }
-  // ── Private: module loading pipeline ────────────────────────
-  async loadModule(bundleUrl, version, expectedHash) {
-    if (this.modules.has(bundleUrl)) return;
-    const storage = getBundleStorage();
-    const index = await storage.loadIndex();
-    const expectedLc = expectedHash ? expectedHash.toLowerCase() : null;
-    let content = null;
-    for (const entry of Object.values(index)) {
-      if (entry.bundleUrl === bundleUrl && entry.version === version) {
-        const age = Date.now() - entry.timestamp;
-        const hashOk = expectedLc && entry.bundleHash && entry.bundleHash.toLowerCase() === expectedLc;
-        if (age < CACHE_TTL && hashOk) {
-          content = await storage.readBundle(entry.localPath);
-          if (content) break;
+      /** True once the boundary has moved since a load captured `epoch` — i.e. a
+       *  tenant switch (or wipe) happened while this load was in flight. Its results
+       *  belong to a tenant that is no longer current and must be discarded. */
+      isStale(epoch, tenant) {
+        return this.epoch !== epoch || (0, import_core9.getTenant)() !== tenant;
+      }
+      /** Record a memory serve: the running bytes are the already-evaluated module,
+       *  and `expected` is refreshed from the manifest hash the caller JUST passed —
+       *  so after a redeploy the record reads hash !== expected (STALE) instead of
+       *  the old in-sync pair. The ONE place both memory paths (load()'s early return
+       *  and loadModule's) record reuse. No-op if nothing was recorded yet. */
+      markMemoryHit(bundleUrl, expectedHash) {
+        const prev = this.provenance.get(bundleUrl);
+        if (prev) {
+          this.provenance.set(bundleUrl, { ...prev, source: "memory", expected: expectedHash?.toLowerCase() ?? prev.expected });
         }
       }
-    }
-    if (!content) {
-      const downloaded = await this.download(bundleUrl, expectedLc);
-      content = downloaded.content;
-      const safeName = bundleUrl.replace(/[^a-zA-Z0-9]/g, "_").slice(-80);
-      try {
-        const localPath = await storage.writeBundle(`${safeName}@${version}.js`, content);
-        index[bundleUrl] = {
-          localPath,
-          version,
-          timestamp: Date.now(),
-          bundleUrl,
-          bundleHash: downloaded.sha256
+      // ── Public API ──────────────────────────────────────────────
+      /**
+       * Load a plugin component. Returns the RegisteredUIPlugin object.
+       * Handles: in-memory cache → disk cache → download → evaluate → extract.
+       *
+       * `expectedHash` (SHA-256 hex from cp.getContextPlugin manifest) MUST be
+       * provided for any bundle the user has not previously verified — without
+       * it, a tampered bundle is `eval`'d as JS with full RN runtime + every
+       * native capability the manifest declares.
+       *
+       * `grants` is what the MANIFEST grants this plugin (resolvePluginGrants) — the
+       * only authority its device tools are registered under. Omitted (e.g. a
+       * prewarm from the slim plugin list) → the bundle is loaded but its tools are
+       * NOT registered: without the manifest there is nothing trusted to gate them
+       * on, and registering with nothing would downgrade a registration the
+       * manifest-driven tool loader already made.
+       */
+      async load(pluginId, bundleUrl, version, expectedHash, grants) {
+        const tenant = this.requireTenant();
+        const epoch = this.epoch;
+        const cached = this.getComponentFromMemory(pluginId, bundleUrl);
+        if (cached) {
+          this.markMemoryHit(bundleUrl, expectedHash);
+          if (grants) await this.commitTools(pluginId, bundleUrl, grants, tenant, epoch);
+          return cached;
+        }
+        let modulePromise = this.inflight.get(bundleUrl);
+        if (!modulePromise) {
+          const promise = this.loadModule(bundleUrl, version, expectedHash, tenant, epoch);
+          modulePromise = promise;
+          this.inflight.set(bundleUrl, promise);
+          promise.catch(() => {
+          }).finally(() => {
+            if (this.inflight.get(bundleUrl) === promise) this.inflight.delete(bundleUrl);
+          });
+        }
+        await modulePromise;
+        if (this.isStale(epoch, tenant)) {
+          throw new Error("[BundleManager] tenant changed while loading \u2014 discarding (fail closed)");
+        }
+        if (grants) await this.commitTools(pluginId, bundleUrl, grants, tenant, epoch);
+        const component = this.getComponentFromMemory(pluginId, bundleUrl);
+        if (!component) {
+          throw new Error(
+            `Bundle loaded from ${bundleUrl} but no component found for "${pluginId}". Available exports: ${this.describeModule(this.modules.get(bundleUrl))}`
+          );
+        }
+        return component;
+      }
+      /**
+       * Load a bundle for its `tools/` section only — no UI required.
+       *
+       * Same download, same integrity check, same evaluation as `load()`; the only
+       * difference is that a bundle exporting tools and no `Component` is a success
+       * here rather than "no component found". Returns the tool names registered.
+       *
+       * `grants` is REQUIRED: the tools are registered under `pluginId` with exactly
+       * what the manifest grants (see load()), never what the bundle claims.
+       */
+      async loadTools(pluginId, bundleUrl, version, expectedHash, grants) {
+        if (!grants) {
+          throw new Error(`[BundleManager] loadTools(${pluginId}) needs the manifest's grants (resolvePluginGrants) \u2014 refusing to register tools on the bundle's own claim`);
+        }
+        const tenant = this.requireTenant();
+        const epoch = this.epoch;
+        let modulePromise = this.inflight.get(bundleUrl);
+        if (!modulePromise) {
+          const promise = this.loadModule(bundleUrl, version, expectedHash, tenant, epoch);
+          modulePromise = promise;
+          this.inflight.set(bundleUrl, promise);
+          promise.catch(() => {
+          }).finally(() => {
+            if (this.inflight.get(bundleUrl) === promise) this.inflight.delete(bundleUrl);
+          });
+        }
+        await modulePromise;
+        if (this.isStale(epoch, tenant)) {
+          throw new Error("[BundleManager] tenant changed while loading tools \u2014 discarding (fail closed)");
+        }
+        await this.commitTools(pluginId, bundleUrl, grants, tenant, epoch);
+        const names = listDeviceTools().filter((t) => t.pluginId === pluginId).map((t) => t.name);
+        if (names.length === 0) {
+          console.warn(
+            `[BundleManager] ${pluginId}: bundle loaded from ${bundleUrl} but registered no tools. Available exports: ${this.describeModule(this.modules.get(bundleUrl))}`
+          );
+        }
+        return names;
+      }
+      /**
+       * Prewarm: load every plugin bundle in the background after app boot, so a
+       * later open is instant (in-memory hit) instead of round-tripping the
+       * network. Errors are swallowed per-plugin — one bad bundle shouldn't
+       * block others. Concurrency capped at 3.
+       */
+      async prewarmAll(items) {
+        const queue = [...items];
+        const concurrency = Math.min(3, queue.length);
+        const start = Date.now();
+        let okCount = 0;
+        let failCount = 0;
+        const worker = async () => {
+          while (queue.length > 0) {
+            const it = queue.shift();
+            if (!it) return;
+            try {
+              await this.load(it.pluginId, it.bundleUrl, it.version, it.bundleHash, it.grants);
+              okCount++;
+            } catch (err) {
+              failCount++;
+              console.log(`[prewarm] ${it.pluginId}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+          }
         };
-        await storage.saveIndex(index);
-      } catch (err) {
-        console.warn("[BundleManager] Cache write error:", err);
+        await Promise.all(Array.from({ length: concurrency }, worker));
+        console.log(`[prewarm] ${okCount} loaded, ${failCount} failed in ${Date.now() - start}ms`);
       }
-    }
-    const mod = this.evaluate(content, bundleUrl);
-    this.modules.set(bundleUrl, mod);
-  }
-  /**
-   * Download + integrity-verify a bundle. Refuses to return when:
-   *   - manifest hash and computed hash disagree
-   *   - server's `X-Bundle-SHA256` disagrees with manifest hash
-   *   - no expected hash AND no server hash header (cannot prove the bundle
-   *     wasn't tampered with — fail closed rather than trust the wire).
-   */
-  async download(bundleUrl, expectedHash) {
-    const cacheBust = `${bundleUrl}${bundleUrl.includes("?") ? "&" : "?"}t=${Date.now()}`;
-    const response = await (0, import_core6.apiFetchRaw)(cacheBust);
-    if (!response.ok) {
-      const body = await response.text().catch(() => "");
-      throw new Error(`Download failed: ${response.status} ${response.statusText} \u2014 ${body.substring(0, 200)}`);
-    }
-    const content = await response.text();
-    if (content.length < 50 || content.trimStart().startsWith("<!")) {
-      throw new Error("Bundle content is empty or HTML \u2014 server may have returned an error page");
-    }
-    const headerHash = (response.headers.get("x-bundle-sha256") || "").toLowerCase();
-    const computed = sha256Hex(content);
-    if (expectedHash) {
-      if (computed !== expectedHash) {
-        throw new Error(
-          `Bundle integrity FAIL: expected sha256=${expectedHash.slice(0, 12)}... got ${computed.slice(0, 12)}.... Refusing to evaluate.`
-        );
+      /**
+       * Clear all caches (in-memory + storage).
+       */
+      async clearAll() {
+        this.dropInMemory();
+        this.cacheTenant = null;
+        try {
+          await getBundleStorage().clearAll();
+        } catch (err) {
+          console.warn("[BundleManager] clearAll error:", err);
+        }
       }
-      if (headerHash && headerHash !== expectedHash) {
-        throw new Error(
-          `Bundle hash mismatch: manifest=${expectedHash.slice(0, 12)}... server=${headerHash.slice(0, 12)}.... Refusing to evaluate.`
-        );
+      /**
+       * Clear cache for a specific plugin/bundle.
+       */
+      async clearPlugin(pluginId) {
+        const storage = getBundleStorage();
+        const index = await storage.loadIndex();
+        const entry = index[pluginId];
+        if (entry) {
+          this.modules.delete(entry.bundleUrl);
+          delete index[pluginId];
+          await storage.saveIndex(index);
+          try {
+            await storage.deleteBundle(entry.localPath);
+          } catch {
+          }
+        }
       }
-    } else if (headerHash) {
-      if (computed !== headerHash) {
-        throw new Error(
-          `Bundle body sha256 (${computed.slice(0, 12)}...) does not match server's X-Bundle-SHA256 (${headerHash.slice(0, 12)}...).`
+      /**
+       * What every loaded bundle IS, right now: the sha256 of the bytes running,
+       * the hash the server advertised, and where they came from.
+       *
+       * Deliberately not filtered or prettified — this is the raw answer to "did my
+       * redeploy reach the phone?", and it is comparable directly against the
+       * manifest `bundleHash` and the server's X-Bundle-SHA256 header.
+       */
+      getLoadedBundles() {
+        return [...this.provenance.values()];
+      }
+      // ── Private: module loading pipeline ────────────────────────
+      async loadModule(bundleUrl, version, expectedHash, expectedTenant, expectedEpoch) {
+        if (this.isStale(expectedEpoch, expectedTenant)) {
+          throw new Error("[BundleManager] tenant changed before load started \u2014 discarding (fail closed)");
+        }
+        if (this.modules.has(bundleUrl)) {
+          this.markMemoryHit(bundleUrl, expectedHash);
+          return;
+        }
+        const storage = getBundleStorage();
+        const index = await storage.loadIndex();
+        const expectedLc = expectedHash ? expectedHash.toLowerCase() : null;
+        let content = null;
+        let verifiedHash = null;
+        let servedFrom = "download";
+        for (const entry of Object.values(index)) {
+          if (entry.bundleUrl === bundleUrl && entry.version === version) {
+            const age = Date.now() - entry.timestamp;
+            const hashOk = expectedLc && entry.bundleHash && entry.bundleHash.toLowerCase() === expectedLc;
+            if (age < CACHE_TTL && hashOk) {
+              content = await storage.readBundle(entry.localPath);
+              if (content) {
+                verifiedHash = entry.bundleHash.toLowerCase();
+                servedFrom = "disk-cache";
+                break;
+              }
+            }
+          }
+        }
+        if (!content) {
+          const downloaded = await this.download(bundleUrl, expectedLc);
+          content = downloaded.content;
+          verifiedHash = downloaded.sha256.toLowerCase();
+          if (this.isStale(expectedEpoch, expectedTenant)) {
+            throw new Error("[BundleManager] tenant changed during download \u2014 discarding (fail closed)");
+          }
+          try {
+            const localPath = await storage.writeBundle(`${verifiedHash}.js`, content);
+            if (!this.isStale(expectedEpoch, expectedTenant)) {
+              index[bundleUrl] = {
+                localPath,
+                version,
+                timestamp: Date.now(),
+                bundleUrl,
+                bundleHash: downloaded.sha256,
+                tenant: expectedTenant
+              };
+              await storage.saveIndex(index);
+            }
+          } catch (err) {
+            console.warn("[BundleManager] Cache write error:", err);
+          }
+        }
+        if (this.isStale(expectedEpoch, expectedTenant)) {
+          throw new Error("[BundleManager] tenant changed while loading \u2014 discarding stale bundle before eval (fail closed)");
+        }
+        const mod = this.evaluate(content, bundleUrl, verifiedHash);
+        this.modules.set(bundleUrl, mod);
+        this.provenance.set(bundleUrl, {
+          bundleUrl,
+          version,
+          hash: verifiedHash,
+          expected: expectedLc,
+          source: servedFrom,
+          // The captured owner — same rule as the disk stamp. The final stale check
+          // above guarantees getTenant() === expectedTenant here, but binding it to
+          // the captured value keeps the ownership record impossible to mislabel.
+          tenant: expectedTenant,
+          loadedAt: Date.now()
+        });
+        console.log(
+          `[BundleManager] RUNNING ${bundleUrl} v${version} sha=${(verifiedHash || "none").slice(0, 12)} (${servedFrom}${expectedLc && verifiedHash && expectedLc !== verifiedHash ? `, EXPECTED ${expectedLc.slice(0, 12)} \u2014 STALE` : ""})`
         );
       }
-      console.warn(`[BundleManager] No manifest bundleHash \u2014 verified via X-Bundle-SHA256 header only`);
-    } else {
-      throw new Error(
-        `No bundleHash in manifest and no X-Bundle-SHA256 header from server. Refusing to evaluate untrusted bundle.`
-      );
-    }
-    return { content, sha256: computed };
-  }
-  evaluate(content, bundleUrl) {
-    let cleaned = content.replace(
-      /__toESM\(require\(("[^"]+")\)(?:,\s*\d+)?\)/g,
-      "require($1)"
-    );
-    cleaned = cleaned.replace(
-      /module\.exports\s*=\s*__toCommonJS\((\w+)\)/g,
-      "module.exports = $1"
-    );
-    const mod = { exports: {} };
-    try {
-      const factory = new Function(
-        "module",
-        "exports",
-        "require",
-        "__filename",
-        "__dirname",
-        cleaned
-      );
-      factory(mod, mod.exports, requireShim, bundleUrl, "adas-plugin-bundles");
-    } catch (err) {
-      throw new Error(`Bundle evaluation failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    const raw = mod.exports;
-    const materialized = {};
-    for (const key of Object.getOwnPropertyNames(raw)) {
-      try {
-        materialized[key] = raw[key];
-      } catch {
+      /**
+       * Register THIS plugin's device tools under the TRUSTED declaration, then
+       * record that declaration on the disk-cache entry. Runs on every trusted load
+       * — memory hit included — so the grants in force are always the latest the
+       * manifest gave (a revoked grant stops applying on the next load, not the next
+       * app start). Callers run it only after their stale check.
+       */
+      async commitTools(pluginId, bundleUrl, grants, tenant, epoch) {
+        const declaration = {
+          pluginId,
+          capabilities: grants.capabilities,
+          stateDomains: grants.stateDomains
+        };
+        this.registerToolsFromModule(this.modules.get(bundleUrl), declaration);
+        await this.recordTrustedDeclaration(bundleUrl, declaration, tenant, epoch);
       }
-    }
-    return materialized;
-  }
-  // ── Private: component extraction ───────────────────────────
-  /**
-   * Find a plugin component in a loaded module.
-   * Handles: default export, direct key match, multi-plugin .id match.
-   */
-  getComponentFromMemory(pluginId, bundleUrl) {
-    const mod = this.modules.get(bundleUrl);
-    if (!mod) return null;
-    const shortName = pluginId.includes(":") ? pluginId.split(":").pop() : pluginId;
-    if (mod[pluginId] && typeof mod[pluginId].Component === "function") {
-      return mod[pluginId];
-    }
-    const pascal = shortName.replace(/(^|-)([a-z])/g, (_, __, c) => c.toUpperCase());
-    if (mod[pascal] && typeof mod[pascal] === "object" && typeof mod[pascal].Component === "function") {
-      return mod[pascal];
-    }
-    if (mod.default && typeof mod.default === "object" && typeof mod.default.Component === "function") {
-      return mod.default;
-    }
-    for (const key of Object.keys(mod)) {
-      const val = mod[key];
-      if (val && typeof val === "object" && val.id === shortName && typeof val.Component === "function") {
-        return val;
+      /**
+       * Put the plugin's own `tools` section in the device tool registry — under the
+       * pluginId and grants the MANIFEST resolved, never the bundle's own `id`,
+       * `capabilities` or `stateDomains`. A bundle is code the manifest authorised
+       * by hash; what it may touch is the manifest's to say, same as its rendered
+       * surface (resolvePluginRuntimeProps). Its own `id` would also let it register
+       * as another plugin — including the host's platform tools, which a same-id
+       * re-registration replaces.
+       *
+       * Only this plugin's export (the same lookup the component uses) is
+       * registered. Another export's tools in the same bundle belong to another
+       * plugin and register when THAT plugin's manifest loads it.
+       */
+      registerToolsFromModule(mod, { pluginId, capabilities, stateDomains }) {
+        if (!mod) return;
+        const own = this.findPluginExport(mod, pluginId, hasTools);
+        const others = Object.keys(mod).filter((k) => hasTools(mod[k]) && mod[k] !== own);
+        if (others.length > 0) {
+          console.warn(
+            `[BundleManager] ${pluginId}: not registering tools from export(s) ${others.join(", ")} \u2014 they are not this plugin's, and only their own manifest can grant them`
+          );
+        }
+        if (!own) return;
+        const ungranted = [
+          ...(Array.isArray(own.stateDomains) ? own.stateDomains : []).filter((d) => !stateDomains?.includes(d)),
+          ...Object.keys(own.capabilities || {}).filter((k) => own.capabilities[k] === true && !capabilities?.[k])
+        ];
+        if (ungranted.length > 0) {
+          console.warn(
+            `[BundleManager] ${pluginId}: bundle declares ${ungranted.join(", ")} but the manifest does not grant it \u2014 denied`
+          );
+        }
+        try {
+          registerDeviceTools(pluginId, own.tools, capabilities, stateDomains);
+          this.registeredToolPluginIds.add(pluginId);
+        } catch (err) {
+          console.warn(
+            `[BundleManager] tool registration failed for ${pluginId}:`,
+            err instanceof Error ? err.message : String(err)
+          );
+        }
       }
-    }
-    return null;
-  }
-  describeModule(mod) {
-    if (!mod) return "(empty)";
-    return Object.keys(mod).map((k) => {
-      const v = mod[k];
-      if (v && typeof v === "object" && v.id) return `${k}(id="${v.id}")`;
-      return k;
-    }).join(", ");
-  }
-};
-var bundleManager = new BundleManager();
-
-// src/bridge/native.ts
-var import_react10 = require("react");
-var import_core7 = require("@ateam-ai-mobile/core");
-function buildContext(pluginId, connectorId) {
-  const user = (0, import_core7.getUser)();
-  return {
-    tenant: (0, import_core7.getTenant)(),
-    pluginId,
-    connectorId,
-    user: user ? { id: user.actorId || "", name: user.name || "", roles: user.roles || [] } : void 0
-  };
-}
-function useNativeBridge(pluginId, connectorId, commandBufferRef) {
-  const initCallbackRef = (0, import_react10.useRef)(null);
-  const commandListenersRef = (0, import_react10.useRef)(/* @__PURE__ */ new Set());
-  const initializedRef = (0, import_react10.useRef)(false);
-  const fireInit = (0, import_react10.useCallback)(() => {
-    if (initializedRef.current || !initCallbackRef.current) return;
-    initCallbackRef.current(buildContext(pluginId, connectorId));
-    initializedRef.current = true;
-  }, [pluginId, connectorId]);
-  const onInit = (0, import_react10.useCallback)((cb) => {
-    initCallbackRef.current = cb;
-    setTimeout(fireInit, 0);
-  }, [fireInit]);
-  const mcpCall = (0, import_react10.useCallback)(async (toolOrConnector, argsOrTool, cIdOrArgs) => {
-    let tool;
-    let args;
-    let cId;
-    if (typeof argsOrTool === "string") {
-      cId = toolOrConnector;
-      tool = argsOrTool;
-      args = cIdOrArgs || {};
-    } else {
-      tool = toolOrConnector;
-      args = argsOrTool;
-      cId = typeof cIdOrArgs === "string" ? cIdOrArgs : void 0;
-    }
-    const targetConnector = cId || connectorId;
-    if (!targetConnector) {
-      console.warn(`[NativeBridge:${pluginId}] mcpCall failed \u2014 no connectorId. tool=${tool}`);
-      throw new Error(`[NativeBridge:${pluginId}] mcpCall requires a connectorId`);
-    }
-    try {
-      const data = await (0, import_core7.connectorCall)(targetConnector, tool, args);
-      if (!data.ok && data.error) {
-        throw new Error(data.error);
+      /**
+       * Record the trusted declaration on this tenant's disk-cache entry for the
+       * bytes RUNNING — the recovery path (tools/loader loadFromDiskCache) has no
+       * manifest and re-registers with exactly this. Only onto an entry this tenant
+       * owns whose hash is the running hash: the grant was issued for these bytes,
+       * and those are the bytes recovery will evaluate. Best-effort — a lost write
+       * leaves no `trusted`, which recovery treats as fail closed.
+       */
+      async recordTrustedDeclaration(bundleUrl, declaration, tenant, epoch) {
+        const key = JSON.stringify(declaration);
+        if (this.recordedDeclarations.get(bundleUrl) === key) return;
+        try {
+          const storage = getBundleStorage();
+          const index = await storage.loadIndex();
+          const entry = index[bundleUrl];
+          const running = this.provenance.get(bundleUrl)?.hash;
+          if (!entry || entry.tenant !== tenant || !running || entry.bundleHash?.toLowerCase() !== running) return;
+          if (this.isStale(epoch, tenant)) return;
+          if (JSON.stringify(entry.trusted) !== key) {
+            index[bundleUrl] = { ...entry, trusted: declaration };
+            await storage.saveIndex(index);
+          }
+          this.recordedDeclarations.set(bundleUrl, key);
+        } catch (err) {
+          console.warn("[BundleManager] could not record trusted declaration:", err);
+        }
       }
-      return (0, import_core7.unwrapMcpResult)(data.result);
-    } catch (err) {
-      console.warn(`[NativeBridge:${pluginId}] mcpCall failed \u2192 connector=${targetConnector} tool=${tool}:`, err?.message || err);
-      throw err;
-    }
-  }, [pluginId, connectorId]);
-  const mcpFetch = (0, import_react10.useCallback)(async (body) => {
-    return (0, import_core7.mcpFetch)(body);
-  }, []);
-  const sendCommand = (0, import_react10.useCallback)((type, payload) => {
-    if (type === "plugin.command.result" && payload?.correlationId) {
-      (0, import_core7.postCommandResult)(payload.correlationId, payload.result, payload.error);
-      return;
-    }
-  }, [pluginId]);
-  const onCommand = (0, import_react10.useCallback)((cb) => {
-    commandListenersRef.current.add(cb);
-    if (commandBufferRef) {
-      const buf = commandBufferRef.current;
-      const remaining = [];
-      for (const cmd of buf) {
-        if (cmd.pluginId === pluginId && cmd.command !== "__focus") {
-          try {
-            cb(cmd.command, { ...cmd.args, correlationId: cmd.correlationId });
-          } catch {
+      /**
+       * Download + integrity-verify a bundle. Refuses to return when:
+       *   - manifest hash and computed hash disagree
+       *   - server's `X-Bundle-SHA256` disagrees with manifest hash
+       *   - no expected hash AND no server hash header (cannot prove the bundle
+       *     wasn't tampered with — fail closed rather than trust the wire).
+       */
+      async download(bundleUrl, expectedHash) {
+        const cacheBust = `${bundleUrl}${bundleUrl.includes("?") ? "&" : "?"}t=${Date.now()}`;
+        const response = await (0, import_core9.apiFetchRaw)(cacheBust);
+        if (!response.ok) {
+          const body = await response.text().catch(() => "");
+          throw new Error(`Download failed: ${response.status} ${response.statusText} \u2014 ${body.substring(0, 200)}`);
+        }
+        const content = await response.text();
+        if (content.length < 50 || content.trimStart().startsWith("<!")) {
+          throw new Error("Bundle content is empty or HTML \u2014 server may have returned an error page");
+        }
+        const headerHash = (response.headers.get("x-bundle-sha256") || "").toLowerCase();
+        const computed = sha256Hex(content);
+        if (expectedHash) {
+          if (computed !== expectedHash) {
+            throw new Error(
+              `Bundle integrity FAIL: expected sha256=${expectedHash.slice(0, 12)}... got ${computed.slice(0, 12)}.... Refusing to evaluate.`
+            );
+          }
+          if (headerHash && headerHash !== expectedHash) {
+            throw new Error(
+              `Bundle hash mismatch: manifest=${expectedHash.slice(0, 12)}... server=${headerHash.slice(0, 12)}.... Refusing to evaluate.`
+            );
           }
+        } else if (headerHash) {
+          if (computed !== headerHash) {
+            throw new Error(
+              `Bundle body sha256 (${computed.slice(0, 12)}...) does not match server's X-Bundle-SHA256 (${headerHash.slice(0, 12)}...).`
+            );
+          }
+          console.warn(`[BundleManager] No manifest bundleHash \u2014 verified via X-Bundle-SHA256 header only`);
         } else {
-          remaining.push(cmd);
+          throw new Error(
+            `No bundleHash in manifest and no X-Bundle-SHA256 header from server. Refusing to evaluate untrusted bundle.`
+          );
         }
+        return { content, sha256: computed };
       }
-      commandBufferRef.current = remaining;
-    }
-    for (const cmd of import_core7.pluginCommandEmitter.drainPluginCommands(pluginId)) {
-      try {
-        cb(cmd.command, { ...cmd.args, correlationId: cmd.correlationId });
-      } catch {
-      }
-    }
-    return () => {
-      commandListenersRef.current.delete(cb);
-    };
-  }, [pluginId, commandBufferRef]);
-  (0, import_react10.useEffect)(() => {
-    const unsub = import_core7.pluginCommandEmitter.on("plugin-command", (cmd) => {
-      if (cmd.pluginId !== pluginId) return;
-      if (cmd.command === "__focus") return;
-      commandListenersRef.current.forEach((fn) => {
+      evaluate(content, bundleUrl, verifiedHash) {
+        assertBundleIntegrity(content, verifiedHash, bundleUrl);
+        let cleaned = content.replace(
+          /__toESM\(require\(("[^"]+")\)(?:,\s*\d+)?\)/g,
+          "require($1)"
+        );
+        cleaned = cleaned.replace(
+          /module\.exports\s*=\s*__toCommonJS\((\w+)\)/g,
+          "module.exports = $1"
+        );
+        const mod = { exports: {} };
         try {
-          fn(cmd.command, { ...cmd.args, correlationId: cmd.correlationId });
-        } catch {
+          const factory = new Function(
+            "module",
+            "exports",
+            "require",
+            "__filename",
+            "__dirname",
+            cleaned
+          );
+          factory(mod, mod.exports, requireShim, bundleUrl, "adas-plugin-bundles");
+        } catch (err) {
+          throw new Error(`Bundle evaluation failed: ${err instanceof Error ? err.message : String(err)}`);
         }
-      });
-    });
-    return unsub;
-  }, [pluginId]);
-  (0, import_react10.useEffect)(() => {
-    const timer = setTimeout(() => {
-      const dispatch = (cmd) => {
-        commandListenersRef.current.forEach((fn) => {
+        const raw = mod.exports;
+        const materialized = {};
+        for (const key of Object.getOwnPropertyNames(raw)) {
           try {
-            fn(cmd.command, { ...cmd.args, correlationId: cmd.correlationId });
+            materialized[key] = raw[key];
           } catch {
           }
-        });
-      };
-      if (commandBufferRef) {
-        const remaining = [];
-        for (const cmd of commandBufferRef.current) {
-          if (cmd.pluginId === pluginId && cmd.command !== "__focus") dispatch(cmd);
-          else remaining.push(cmd);
         }
-        commandBufferRef.current = remaining;
+        return materialized;
       }
-      for (const cmd of import_core7.pluginCommandEmitter.drainPluginCommands(pluginId)) {
-        dispatch(cmd);
+      // ── Private: component extraction ───────────────────────────
+      /** Find a plugin component in a loaded module. */
+      getComponentFromMemory(pluginId, bundleUrl) {
+        return this.findPluginExport(this.modules.get(bundleUrl), pluginId, hasComponent);
+      }
+      /**
+       * Find THIS plugin's export in a loaded module — the one lookup both the
+       * component and the device tools use, so a plugin's UI and its tools always
+       * come from the same export. `accept` says what the caller needs from it.
+       * Handles: direct key match, PascalCase key, default export, multi-plugin .id match.
+       */
+      findPluginExport(mod, pluginId, accept) {
+        if (!mod) return null;
+        const shortName = pluginId.includes(":") ? pluginId.split(":").pop() : pluginId;
+        if (accept(mod[pluginId])) return mod[pluginId];
+        const pascal = shortName.replace(/(^|-)([a-z])/g, (_, __, c) => c.toUpperCase());
+        if (accept(mod[pascal])) return mod[pascal];
+        if (accept(mod.default)) return mod.default;
+        for (const key of Object.keys(mod)) {
+          const val = mod[key];
+          if (val && (val.id === pluginId || val.id === shortName) && accept(val)) return val;
+        }
+        return null;
+      }
+      describeModule(mod) {
+        if (!mod) return "(empty)";
+        return Object.keys(mod).map((k) => {
+          const v = mod[k];
+          if (v && typeof v === "object" && v.id) return `${k}(id="${v.id}")`;
+          return k;
+        }).join(", ");
       }
-    }, 500);
-    return () => clearTimeout(timer);
-  }, [pluginId, commandBufferRef]);
-  (0, import_react10.useEffect)(() => {
-    return () => {
-      commandListenersRef.current.clear();
-      initializedRef.current = false;
     };
-  }, []);
-  const close = (0, import_react10.useCallback)(() => {
-    import_core7.pluginCommandEmitter.emit("plugin-close", { pluginId });
-  }, [pluginId]);
-  const sendMessage = (0, import_react10.useCallback)((text) => {
-    const t = (text || "").trim();
-    if (!t) return;
-    try {
-      import_core7.useChatStore.getState().sendMessage(t);
-    } catch (err) {
-      console.warn("[bridge.sendMessage] failed:", err instanceof Error ? err.message : String(err));
-    }
-  }, []);
-  const prepareMessage = (0, import_react10.useCallback)((text) => {
-    const t = (text || "").trim();
-    if (!t) return;
-    import_core7.pluginCommandEmitter.emit("prepare-chat-message", { text: t });
-  }, []);
-  return (0, import_react10.useMemo)(
-    () => ({ onInit, mcpCall, mcpFetch, sendCommand, onCommand, close, sendMessage, prepareMessage }),
-    [onInit, mcpCall, mcpFetch, sendCommand, onCommand, close, sendMessage, prepareMessage]
-  );
-}
-function createNativeBridge(pluginId, connectorId) {
-  const commandListeners = /* @__PURE__ */ new Set();
-  return {
-    onInit(cb) {
-      setTimeout(() => {
-        cb(buildContext(pluginId, connectorId));
-      }, 0);
-    },
-    async mcpCall(tool, args, cId) {
-      const targetConnector = cId || connectorId;
-      if (!targetConnector) {
-        throw new Error(`[NativeBridge:${pluginId}] mcpCall requires a connectorId`);
+    bundleManager = new BundleManager();
+  }
+});
+
+// src/tools/loader.ts
+var loader_exports = {};
+__export(loader_exports, {
+  ensureDeviceToolsLoaded: () => ensureDeviceToolsLoaded,
+  resetDeviceToolLoader: () => resetDeviceToolLoader
+});
+async function ensureDeviceToolsLoaded({ force = false } = {}) {
+  if (loadedOnce && !force) return listDeviceTools().map((t) => t.name);
+  if (inflight) return inflight;
+  inflight = (async () => {
+    try {
+      const summaries = await listPlugins();
+      const manifests = await Promise.all(
+        (summaries || []).map(
+          (s) => getPlugin(s.id).catch(() => null)
+        )
+      );
+      const targets = manifests.filter((m) => {
+        const declared = m?.capabilities?.device_tools;
+        return Array.isArray(declared) && declared.length > 0;
+      });
+      if (targets.length === 0) {
+        const recovered = await loadFromDiskCache();
+        if (recovered.length > 0) {
+          console.log(`[deviceTools] catalog listed none \u2014 recovered from cache: ${recovered.join(", ")}`);
+          return recovered;
+        }
+        console.log("[deviceTools] no device tools available yet \u2014 will look again next call");
+        return [];
       }
-      const data = await (0, import_core7.connectorCall)(targetConnector, tool, args);
-      if (!data.ok && data.error) throw new Error(data.error);
-      return (0, import_core7.unwrapMcpResult)(data.result);
-    },
-    async mcpFetch(body) {
-      return (0, import_core7.mcpFetch)(body);
-    },
-    sendCommand(_type, _payload) {
-    },
-    onCommand(cb) {
-      commandListeners.add(cb);
-      return () => {
-        commandListeners.delete(cb);
-      };
-    },
-    close() {
-      import_core7.pluginCommandEmitter.emit("plugin-close", { pluginId });
-    },
-    sendMessage(text) {
-      const t = (text || "").trim();
-      if (!t) return;
+      await Promise.all(
+        targets.map(async (m) => {
+          const bundleUrl = getNativeBundleUrl(m);
+          if (!bundleUrl) {
+            console.warn(`[deviceTools] ${m.id} declares device_tools but has no native bundle`);
+            return;
+          }
+          try {
+            await bundleManager.loadTools(
+              m.id,
+              bundleUrl,
+              m.version || "1.0.0",
+              getNativeBundleHash(m) || void 0,
+              resolvePluginGrants({ pluginId: m.id, manifest: m })
+            );
+          } catch (err) {
+            console.warn(`[deviceTools] ${m.id} failed to load:`, err?.message || String(err));
+          }
+        })
+      );
+      const names = listDeviceTools().map((t) => t.name);
+      loadedOnce = names.length > 0;
+      console.log(`[deviceTools] ready: ${names.length > 0 ? names.join(", ") : "(none registered \u2014 will retry next call)"}`);
+      return names;
+    } finally {
+      inflight = null;
+    }
+  })();
+  return inflight;
+}
+async function loadFromDiskCache() {
+  try {
+    const index = await getBundleStorage().loadIndex();
+    const entries = Object.values(index || {});
+    if (entries.length === 0) return [];
+    const tenant = (0, import_core10.getTenant)();
+    if (!tenant) {
+      console.warn("[deviceTools] disk-cache recovery skipped \u2014 no active tenant");
+      return [];
+    }
+    const mine = selectOwnedCacheEntries(entries, tenant);
+    const skipped = entries.length - mine.length;
+    if (skipped > 0) {
+      console.log(`[deviceTools] disk-cache recovery: ${mine.length} for "${tenant}", skipped ${skipped} not owned by it`);
+    }
+    const declared = mine.filter((e) => !!e.trusted?.pluginId);
+    if (declared.length < mine.length) {
+      console.log(
+        `[deviceTools] disk-cache recovery: skipped ${mine.length - declared.length} with no recorded manifest grant (fail closed)`
+      );
+    }
+    if (declared.length === 0) return [];
+    await Promise.all(declared.map(async (e) => {
       try {
-        import_core7.useChatStore.getState().sendMessage(t);
-      } catch (err) {
-        console.warn("[bridge.sendMessage] failed:", err instanceof Error ? err.message : String(err));
+        await bundleManager.loadTools(e.trusted.pluginId, e.bundleUrl, e.version, e.bundleHash, e.trusted);
+      } catch {
       }
+    }));
+    return listDeviceTools().map((t) => t.name);
+  } catch (err) {
+    console.warn("[deviceTools] disk-cache recovery failed:", err?.message || String(err));
+    return [];
+  }
+}
+function resetDeviceToolLoader() {
+  loadedOnce = false;
+}
+var import_core10, inflight, loadedOnce;
+var init_loader = __esm({
+  "src/tools/loader.ts"() {
+    "use strict";
+    init_plugins();
+    init_bundleManager();
+    init_registry();
+    init_storage();
+    init_pluginRuntime();
+    import_core10 = require("@ateam-ai-mobile/core");
+    inflight = null;
+    loadedOnce = false;
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ActionButton: () => ActionButton,
+  ActivityIndicator: () => import_react_native.ActivityIndicator,
+  AdaOrb: () => AdaOrb,
+  Animated: () => import_react_native.Animated,
+  Badge: () => Badge,
+  CameraPreview: () => CameraPreview,
+  Card: () => Card,
+  EmptyState: () => EmptyState,
+  ErrorState: () => ErrorState,
+  FlatList: () => import_react_native.FlatList,
+  Image: () => import_react_native.Image,
+  ListItem: () => ListItem,
+  LoadingState: () => LoadingState,
+  MemoryBundleStorage: () => MemoryBundleStorage,
+  Modal: () => import_react_native.Modal,
+  PLATFORM_VOICE_CALLER: () => PLATFORM_VOICE_CALLER,
+  Platform: () => import_react_native.Platform,
+  PluginSDK: () => PluginSDK,
+  Pressable: () => import_react_native.Pressable,
+  RefreshControl: () => import_react_native.RefreshControl,
+  ScrollView: () => import_react_native.ScrollView,
+  SearchBar: () => SearchBar,
+  SectionList: () => import_react_native.SectionList,
+  StyleSheet: () => import_react_native.StyleSheet,
+  SurfaceCard: () => SurfaceCard,
+  SurfaceDispatcher: () => SurfaceDispatcher,
+  SurfaceDrawer: () => SurfaceDrawer,
+  SurfaceFullscreen: () => SurfaceFullscreen,
+  Switch: () => import_react_native.Switch,
+  TabBar: () => TabBar,
+  Text: () => import_react_native.Text,
+  TextInput: () => import_react_native.TextInput,
+  TouchableOpacity: () => import_react_native.TouchableOpacity,
+  View: () => import_react_native.View,
+  __resetSessionSyncForTest: () => __resetSessionSyncForTest,
+  bundleManager: () => bundleManager,
+  callDeviceTool: () => callDeviceTool,
+  clearDeviceTools: () => clearDeviceTools,
+  createNativeBridge: () => createNativeBridge,
+  deviceStateV2: () => device_state_exports,
+  deviceToolsActionForSession: () => deviceToolsActionForSession,
+  ensureDeviceToolsLoaded: () => ensureDeviceToolsLoaded,
+  explainCapability: () => explainCapability,
+  gateDeviceState: () => gateDeviceState,
+  gatePluginNative: () => gatePluginNative,
+  gateVoice: () => gateVoice,
+  getCameraPreviewProvider: () => getCameraPreviewProvider,
+  getHaptics: () => getHaptics,
+  getNativeBundleHash: () => getNativeBundleHash,
+  getNativeBundleUrl: () => getNativeBundleUrl,
+  getNativeComponentId: () => getNativeComponentId,
+  getPlugin: () => getPlugin,
+  getPluginNative: () => getPluginNative,
+  handleServerDeviceToolCall: () => handleServerDeviceToolCall,
+  hasDeviceTool: () => hasDeviceTool,
+  implementedStateDomains: () => implementedStateDomains,
+  implementedVoice: () => implementedVoice,
+  isActionable: () => isActionable,
+  isDeviceToolCommand: () => isDeviceToolCommand,
+  isInlineSurface: () => isInlineSurface,
+  isMountSurface: () => isMountSurface,
+  listDeviceTools: () => listDeviceTools,
+  listPlugins: () => listPlugins,
+  nativePluginRegistry: () => nativePluginRegistry,
+  neverObserved: () => neverObserved,
+  register: () => register,
+  registerBundleModules: () => registerBundleModules,
+  registerDeviceTools: () => registerDeviceTools,
+  registerNativePlugin: () => registerNativePlugin,
+  registerPlatformDeviceTools: () => registerPlatformDeviceTools,
+  registerService: () => registerService,
+  registerTools: () => registerTools,
+  resetDeviceToolLoader: () => resetDeviceToolLoader,
+  resolvePluginGrants: () => resolvePluginGrants,
+  resolvePluginRuntimeProps: () => resolvePluginRuntimeProps,
+  resolvePluginUrl: () => resolvePluginUrl,
+  setBundleStorage: () => setBundleStorage,
+  setCameraPreviewProvider: () => setCameraPreviewProvider,
+  setDeviceStateProvider: () => setDeviceStateProvider,
+  setDeviceToolContextProvider: () => setDeviceToolContextProvider,
+  setDeviceToolResultPoster: () => setDeviceToolResultPoster,
+  setHapticsProvider: () => setHapticsProvider,
+  setPluginNativeProvider: () => setPluginNativeProvider,
+  setPluginThemeColors: () => setPluginThemeColors,
+  setVoiceProvider: () => setVoiceProvider,
+  supportsNative: () => supportsNative,
+  supportsWebView: () => supportsWebView,
+  syncDeviceToolsForSession: () => syncDeviceToolsForSession,
+  unregisterDeviceTools: () => unregisterDeviceTools,
+  unregisterNativePlugin: () => unregisterNativePlugin,
+  useApi: () => useApi,
+  useNativeBridge: () => useNativeBridge,
+  usePlugin: () => usePlugin,
+  usePluginTheme: () => usePluginTheme,
+  useRemotePlugins: () => useRemotePlugins,
+  useSurfaceStore: () => useSurfaceStore
+});
+module.exports = __toCommonJS(index_exports);
+init_sdk();
+
+// src/sdk/device-state.ts
+var device_state_exports = {};
+__export(device_state_exports, {
+  DeviceBridgeError: () => DeviceBridgeError,
+  explainCapability: () => explainCapability,
+  isActionable: () => isActionable,
+  neverObserved: () => neverObserved
+});
+var DeviceBridgeError = class extends Error {
+  constructor(code, message, opts) {
+    super(message);
+    this.name = "DeviceBridgeError";
+    this.code = code;
+    this.domain = opts?.domain;
+    this.recoverable = opts?.recoverable;
+  }
+};
+var CONFIDENCE_ORDER = {
+  unknown: 0,
+  low: 1,
+  medium: 2,
+  high: 3
+};
+function isActionable(quality, budget) {
+  const { freshness, confidence } = quality;
+  if (freshness.state === "unknown" || freshness.state === "stale") return false;
+  if (freshness.ageMs === null || freshness.ageMs > budget.maxAgeMs) return false;
+  if (budget.minConfidence) {
+    const have = CONFIDENCE_ORDER[confidence?.level ?? "unknown"];
+    if (have < CONFIDENCE_ORDER[budget.minConfidence]) return false;
+  }
+  return true;
+}
+function neverObserved() {
+  return { state: "unknown", observedAt: null, ageMs: null };
+}
+function explainCapability(status) {
+  if (status.support === "unsupported") return "this device does not have it";
+  if (status.permission === "denied") return "permission was denied";
+  if (status.permission === "restricted") return "permission is restricted";
+  if (status.permission === "notDetermined") return "permission has not been asked for yet";
+  if (status.permission === "limited") return "only limited access was granted";
+  if (status.restriction === "policyRestricted") return "this plugin did not declare it";
+  if (status.restriction === "backgroundRestricted") return "the app is in the background";
+  if (status.restriction === "lowPowerRestricted") return "the device is in low-power mode";
+  if (status.availability === "busy") return "it is in use by something else";
+  if (status.availability === "temporarilyUnavailable") return "it is temporarily unavailable";
+  if (status.availability === "unavailable") return "it is unavailable";
+  if (status.support === "unknown" || status.availability === "unknown") {
+    return "its state could not be determined";
+  }
+  return null;
+}
+
+// src/index.ts
+init_deviceStateHost();
+init_voiceHost();
+init_host();
+init_pluginRuntime();
+init_registry();
+init_loader();
+
+// src/tools/platformTools.ts
+init_registry();
+var PLATFORM_PLUGIN_ID = "platform:device-tools";
+function registerPlatformDeviceTools() {
+  registerDeviceTools(PLATFORM_PLUGIN_ID, [
+    {
+      name: "device.echo",
+      description: "Echo a string back from the user's own device.",
+      input_schema: {
+        type: "object",
+        properties: { text: { type: "string" } },
+        required: ["text"]
+      },
+      run: (args) => ({
+        ok: true,
+        echoed: args && args.text || "",
+        // The proof: a server-side implementation could not say this truthfully.
+        ran_on: "device"
+      })
     },
-    prepareMessage(text) {
-      const t = (text || "").trim();
-      if (!t) return;
-      import_core7.pluginCommandEmitter.emit("prepare-chat-message", { text: t });
+    {
+      name: "device.ping",
+      description: "Check that the device is reachable.",
+      input_schema: { type: "object", properties: {} },
+      run: () => ({ ok: true, ran_on: "device", at: (/* @__PURE__ */ new Date()).toISOString() })
     }
-  };
+  ]);
+}
+
+// src/tools/sessionSync.ts
+init_registry();
+function deviceToolsActionForSession(next, prevTenant2) {
+  const tenant = next.authenticated ? next.tenant ?? null : null;
+  if (tenant && tenant !== prevTenant2) return { action: "load", tenant };
+  if (!tenant && prevTenant2) return { action: "reset", tenant: null };
+  return { action: "none", tenant: prevTenant2 };
+}
+var REAL_DEPS = {
+  clear: clearDeviceTools,
+  registerPlatform: registerPlatformDeviceTools,
+  // `./loader` reaches react-native via the bundle manager; import it only when
+  // an effect actually fires (real app), never at module load (tests).
+  resetLoader: () => {
+    void Promise.resolve().then(() => (init_loader(), loader_exports)).then((m) => m.resetDeviceToolLoader());
+  },
+  load: () => {
+    void Promise.resolve().then(() => (init_loader(), loader_exports)).then((m) => {
+      m.resetDeviceToolLoader();
+      return m.ensureDeviceToolsLoaded({ force: true });
+    });
+  }
+};
+var prevTenant = null;
+function syncDeviceToolsForSession(next, deps = REAL_DEPS) {
+  const { action, tenant } = deviceToolsActionForSession(next, prevTenant);
+  prevTenant = tenant;
+  if (action === "load") {
+    deps.clear();
+    deps.registerPlatform();
+    deps.load();
+  } else if (action === "reset") {
+    deps.resetLoader();
+  }
+  return action;
+}
+function __resetSessionSyncForTest() {
+  prevTenant = null;
+}
+
+// src/tools/serverCalls.ts
+init_registry();
+init_loader();
+var postResult = null;
+function setDeviceToolResultPoster(fn) {
+  postResult = fn;
+}
+function isDeviceToolCommand(cmd) {
+  return !!cmd && cmd.kind === "device_tool" && typeof cmd.tool === "string" && !!cmd.correlationId;
+}
+async function handleServerDeviceToolCall(cmd) {
+  if (!isDeviceToolCommand(cmd)) return;
+  const { tool, args, correlationId } = cmd;
+  if (!postResult) {
+    console.warn("[deviceTools] server called a tool but no result poster is installed");
+    return;
+  }
+  try {
+    await ensureDeviceToolsLoaded();
+    const outcome = await callDeviceTool(tool, args || {});
+    console.log(`[deviceTools] server-called ${tool} \u2192 ${outcome.ok ? "ok" : outcome.reason}`);
+    await postResult(
+      correlationId,
+      outcome.ok ? { ok: true, ...unwrap(outcome.result) } : void 0,
+      outcome.ok ? void 0 : outcome.error
+    );
+  } catch (err) {
+    await postResult(correlationId, void 0, err?.message || String(err)).catch(() => {
+    });
+  }
 }
+function unwrap(result) {
+  if (result && typeof result === "object" && !Array.isArray(result)) return result;
+  return { result };
+}
+
+// src/index.ts
+init_bundleManager();
+init_storage();
+init_native();
 
 // src/hooks/usePlugin.ts
 var import_react11 = require("react");
+init_bundleManager();
+init_host();
+init_pluginRuntime();
 function extractBundleUrl(pluginId, manifest) {
   const render = manifest.render;
   if (!render || typeof render !== "object") return { url: null, source: "none" };
@@ -2122,6 +3454,8 @@ function usePlugin(pluginId, manifest) {
   const bundleHash = extractBundleHash(manifest);
   const componentId = extractComponentId(manifest);
   const lookupId = componentId || pluginId;
+  const grants = resolvePluginGrants({ pluginId, manifest });
+  const grantsKey = JSON.stringify(grants);
   if (ignoredUrl) {
     console.warn(`[usePlugin] ${pluginId}: IGNORED connector-injected bundleUrl="${ignoredUrl}". The host derives bundle URLs from pluginId via the canonical route.`);
   }
@@ -2144,7 +3478,7 @@ function usePlugin(pluginId, manifest) {
         }
         if (bundleUrl) {
           try {
-            const component = await bundleManager.load(pluginId, bundleUrl, version, bundleHash);
+            const component = await bundleManager.load(pluginId, bundleUrl, version, bundleHash, grants);
             if (cancelled) return;
             setPlugin(component);
             setLoading(false);
@@ -2181,13 +3515,13 @@ function usePlugin(pluginId, manifest) {
     return () => {
       cancelled = true;
     };
-  }, [pluginId, lookupId, bundleUrl, bundleHash, version]);
+  }, [pluginId, lookupId, bundleUrl, bundleHash, version, grantsKey]);
   return { plugin, loading, error, bundleMissing };
 }
 
 // src/hooks/useRemotePlugins.ts
 var import_react12 = require("react");
-var import_core8 = require("@ateam-ai-mobile/core");
+var import_core11 = require("@ateam-ai-mobile/core");
 function useRemotePlugins(solutionId) {
   const [plugins, setPlugins] = (0, import_react12.useState)([]);
   const [loading, setLoading] = (0, import_react12.useState)(true);
@@ -2199,7 +3533,7 @@ function useRemotePlugins(solutionId) {
       const targetSolutionId = solutionId || "current";
       let data;
       try {
-        data = await (0, import_core8.apiFetch)(`/api/solutions/${targetSolutionId}/ui-plugins`);
+        data = await (0, import_core11.apiFetch)(`/api/solutions/${targetSolutionId}/ui-plugins`);
       } catch (err) {
         if (err?.message?.includes("404")) {
           console.warn(`[useRemotePlugins] Solution ${targetSolutionId} not found or has no plugins`);
@@ -2255,108 +3589,14 @@ function useRemotePlugins(solutionId) {
   };
 }
 
-// src/api/plugins.ts
-var import_core9 = require("@ateam-ai-mobile/core");
-var import_core10 = require("@ateam-ai-mobile/core");
-function supportsNative(manifest) {
-  const mode = manifest.render?.mode;
-  return mode === "react-native" || mode === "adaptive";
-}
-function getNativeComponentId(manifest) {
-  if (manifest.render?.mode === "react-native") return manifest.render.component;
-  if (manifest.render?.mode === "adaptive") return manifest.render.reactNative?.component;
-  return null;
-}
-function getNativeBundleUrl(manifest) {
-  const direct = manifest.bundleUrl;
-  if (direct) return direct;
-  const render = manifest.render;
-  if (render.mode === "react-native") return render.bundleUrl || null;
-  if (render.mode === "adaptive") return render.reactNative?.bundleUrl || null;
-  return null;
-}
-function getNativeBundleHash(manifest) {
-  const direct = manifest.bundleHash;
-  if (direct) return direct;
-  const render = manifest.render;
-  if (render.mode === "react-native") return render.bundleHash || null;
-  if (render.mode === "adaptive") return render.reactNative?.bundleHash || null;
-  return null;
-}
-function supportsWebView(manifest) {
-  return manifest.render?.mode === "iframe" || manifest.render?.mode === "adaptive";
-}
-async function listPlugins() {
-  const res = await (0, import_core9.apiFetch)("/mcp", {
-    method: "POST",
-    body: JSON.stringify({
-      jsonrpc: "2.0",
-      id: Date.now(),
-      method: "tools/call",
-      params: {
-        name: "cp.listContextPlugins",
-        arguments: {}
-      }
-    })
-  });
-  const structured = res.result?.structuredContent?.plugins;
-  if (structured) return structured;
-  const text = res.result?.content?.[0]?.text;
-  if (!text) return [];
-  try {
-    const parsed = JSON.parse(text);
-    return parsed.plugins || parsed || [];
-  } catch {
-    return [];
-  }
-}
-async function getPlugin(pluginId) {
-  const res = await (0, import_core9.apiFetch)("/mcp", {
-    method: "POST",
-    body: JSON.stringify({
-      jsonrpc: "2.0",
-      id: Date.now(),
-      method: "tools/call",
-      params: {
-        name: "cp.getContextPlugin",
-        arguments: { id: pluginId }
-        // Backend expects { id }, NOT { pluginId }
-      }
-    })
-  });
-  if (res.result?.structuredContent) return res.result.structuredContent;
-  const text = res.result?.content?.[0]?.text;
-  if (!text) return null;
-  try {
-    const parsed = JSON.parse(text);
-    if (parsed.error) {
-      console.warn("[getPlugin] Backend error:", parsed.error);
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-function resolvePluginUrl(manifest, tenant) {
-  const render = manifest.render;
-  let url;
-  if (render?.mode === "iframe") {
-    url = render.iframeUrl;
-  } else if (render?.mode === "adaptive") {
-    url = render.iframeUrl || render.iframe?.iframeUrl;
-  }
-  if (!url) return "";
-  if (url.startsWith("http")) {
-    const sep = url.includes("?") ? "&" : "?";
-    return tenant ? `${url}${sep}tenant=${encodeURIComponent(tenant)}` : url;
-  }
-  if (tenant && url.startsWith("/mcp-ui/")) {
-    const tenantUrl = url.replace("/mcp-ui/", `/mcp-ui/${encodeURIComponent(tenant)}/`);
-    return `${(0, import_core10.getCoreApiUrl)()}${tenantUrl}`;
-  }
-  return `${(0, import_core10.getCoreApiUrl)()}${url}`;
-}
+// src/index.ts
+init_plugins();
+init_SurfaceDrawer();
+init_SurfaceCard();
+init_SurfaceFullscreen();
+init_AdaOrb();
+init_store();
+init_SurfaceDispatcher();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ActionButton,
@@ -2364,6 +3604,7 @@ function resolvePluginUrl(manifest, tenant) {
   AdaOrb,
   Animated,
   Badge,
+  CameraPreview,
   Card,
   EmptyState,
   ErrorState,
@@ -2373,6 +3614,7 @@ function resolvePluginUrl(manifest, tenant) {
   LoadingState,
   MemoryBundleStorage,
   Modal,
+  PLATFORM_VOICE_CALLER,
   Platform,
   PluginSDK,
   Pressable,
@@ -2391,30 +3633,61 @@ function resolvePluginUrl(manifest, tenant) {
   TextInput,
   TouchableOpacity,
   View,
+  __resetSessionSyncForTest,
   bundleManager,
+  callDeviceTool,
+  clearDeviceTools,
   createNativeBridge,
+  deviceStateV2,
+  deviceToolsActionForSession,
+  ensureDeviceToolsLoaded,
+  explainCapability,
+  gateDeviceState,
   gatePluginNative,
+  gateVoice,
+  getCameraPreviewProvider,
   getHaptics,
   getNativeBundleHash,
   getNativeBundleUrl,
   getNativeComponentId,
   getPlugin,
   getPluginNative,
+  handleServerDeviceToolCall,
+  hasDeviceTool,
+  implementedStateDomains,
+  implementedVoice,
+  isActionable,
+  isDeviceToolCommand,
   isInlineSurface,
   isMountSurface,
+  listDeviceTools,
   listPlugins,
   nativePluginRegistry,
+  neverObserved,
   register,
   registerBundleModules,
+  registerDeviceTools,
   registerNativePlugin,
+  registerPlatformDeviceTools,
   registerService,
+  registerTools,
+  resetDeviceToolLoader,
+  resolvePluginGrants,
+  resolvePluginRuntimeProps,
   resolvePluginUrl,
   setBundleStorage,
+  setCameraPreviewProvider,
+  setDeviceStateProvider,
+  setDeviceToolContextProvider,
+  setDeviceToolResultPoster,
   setHapticsProvider,
   setPluginNativeProvider,
   setPluginThemeColors,
+  setVoiceProvider,
   supportsNative,
   supportsWebView,
+  syncDeviceToolsForSession,
+  unregisterDeviceTools,
   unregisterNativePlugin,
   useApi,
   useNativeBridge,