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

package/dist/chunk-RXR6M623.mjs

@@ -0,0 +1,3085 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/api/plugins.ts
+import { apiFetch } from "@ateam-ai-mobile/core";
+import { getCoreApiUrl } from "@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 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 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 `${getCoreApiUrl()}${tenantUrl}`;
+  }
+  return `${getCoreApiUrl()}${url}`;
+}
+
+// src/bundles/bundleManager.ts
+import React2 from "react";
+import {
+  useState,
+  useEffect as useEffect6,
+  useCallback as useCallback2,
+  useMemo as useMemo4,
+  useRef as useRef4,
+  useContext,
+  useReducer,
+  useLayoutEffect,
+  useImperativeHandle,
+  useDebugValue
+} from "react";
+import * as ReactNative from "react-native";
+import { apiFetchRaw, getTenant as getTenant2 } from "@ateam-ai-mobile/core";
+
+// src/sdk/index.ts
+var sdk_exports = {};
+__export(sdk_exports, {
+  ActionButton: () => ActionButton,
+  ActivityIndicator: () => ActivityIndicator,
+  Animated: () => Animated,
+  Badge: () => Badge,
+  CameraPreview: () => CameraPreview,
+  Card: () => Card,
+  EmptyState: () => EmptyState,
+  ErrorState: () => ErrorState,
+  FlatList: () => FlatList,
+  Image: () => Image,
+  ListItem: () => ListItem,
+  LoadingState: () => LoadingState,
+  Modal: () => Modal,
+  PLATFORM_VOICE_CALLER: () => PLATFORM_VOICE_CALLER,
+  Platform: () => Platform,
+  PluginSDK: () => PluginSDK,
+  Pressable: () => Pressable,
+  RefreshControl: () => RefreshControl,
+  ScrollView: () => ScrollView,
+  SearchBar: () => SearchBar,
+  SectionList: () => SectionList,
+  StyleSheet: () => StyleSheet,
+  Switch: () => Switch,
+  TabBar: () => TabBar,
+  Text: () => Text,
+  TextInput: () => TextInput,
+  TouchableOpacity: () => TouchableOpacity,
+  View: () => View,
+  register: () => register,
+  registerService: () => registerService,
+  registerTools: () => registerTools,
+  setPluginThemeColors: () => setPluginThemeColors,
+  useApi: () => useApi,
+  usePluginTheme: () => usePluginTheme
+});
+
+// src/sdk/registration.ts
+function register(id, config) {
+  return {
+    id,
+    type: config.type || "ui",
+    capabilities: config.capabilities,
+    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) {
+  return {
+    id,
+    type: "service",
+    capabilities: config.capabilities,
+    hooks: config.hooks,
+    onStart: config.onStart,
+    onStop: config.onStop
+  };
+}
+
+// src/sdk/voice.ts
+var PLATFORM_VOICE_CALLER = /* @__PURE__ */ Symbol("adas.voice.platform");
+
+// src/sdk/primitives.ts
+import {
+  View,
+  Text,
+  ScrollView,
+  FlatList,
+  SectionList,
+  Pressable,
+  TouchableOpacity,
+  TextInput,
+  Image,
+  ActivityIndicator,
+  Modal,
+  Switch,
+  StyleSheet,
+  Animated,
+  Platform,
+  RefreshControl
+} from "react-native";
+
+// src/sdk/components.ts
+import React from "react";
+import {
+  View as View2,
+  Text as Text2,
+  Pressable as Pressable2,
+  TextInput as TextInput2,
+  ActivityIndicator as ActivityIndicator2,
+  StyleSheet as StyleSheet2
+} from "react-native";
+function Card({ theme, children, style, onPress }) {
+  const cardStyle = [
+    styles.card,
+    {
+      backgroundColor: theme.colors.surface,
+      borderColor: theme.colors.border
+    },
+    style
+  ];
+  if (onPress) {
+    return React.createElement(Pressable2, { style: cardStyle, onPress }, children);
+  }
+  return React.createElement(View2, { 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 React.createElement(
+    View2,
+    {
+      style: [
+        styles.badge,
+        {
+          backgroundColor: theme.colors[mapping.bg],
+          borderRadius: theme.borderRadius.sm
+        },
+        style
+      ]
+    },
+    React.createElement(Text2, {
+      style: [styles.badgeText, { color: theme.colors[mapping.text] }]
+    }, label)
+  );
+}
+function TabBar({ theme, tabs, activeTab, onTabChange, style }) {
+  return React.createElement(
+    View2,
+    {
+      style: [
+        styles.tabBar,
+        { borderBottomColor: theme.colors.border },
+        style
+      ]
+    },
+    tabs.map(
+      (tab) => React.createElement(
+        Pressable2,
+        {
+          key: tab,
+          style: [
+            styles.tab,
+            {
+              borderBottomColor: tab === activeTab ? theme.colors.accent : "transparent"
+            }
+          ],
+          onPress: () => onTabChange(tab)
+        },
+        React.createElement(Text2, {
+          style: {
+            color: tab === activeTab ? theme.colors.accent : theme.colors.textSecondary,
+            fontSize: theme.fontSize.sm,
+            fontWeight: tab === activeTab ? "600" : "400"
+          }
+        }, tab)
+      )
+    )
+  );
+}
+function ListItem({ theme, title, subtitle, right, onPress, style }) {
+  const content = [
+    React.createElement(
+      View2,
+      { key: "content", style: styles.listItemContent },
+      React.createElement(Text2, {
+        style: { color: theme.colors.text, fontSize: theme.fontSize.md },
+        numberOfLines: 1
+      }, title),
+      subtitle ? React.createElement(Text2, {
+        style: { color: theme.colors.textSecondary, fontSize: theme.fontSize.xs, marginTop: 2 },
+        numberOfLines: 1
+      }, subtitle) : null
+    ),
+    right ? React.createElement(View2, { key: "right" }, right) : null
+  ];
+  if (onPress) {
+    return React.createElement(
+      Pressable2,
+      { style: [styles.listItem, { borderBottomColor: theme.colors.border }, style], onPress },
+      ...content
+    );
+  }
+  return React.createElement(
+    View2,
+    { style: [styles.listItem, { borderBottomColor: theme.colors.border }, style] },
+    ...content
+  );
+}
+function SearchBar({ theme, value, onChangeText, placeholder = "Search...", style }) {
+  return React.createElement(TextInput2, {
+    style: [
+      styles.searchBar,
+      {
+        backgroundColor: theme.colors.input,
+        color: theme.colors.text,
+        borderColor: theme.colors.border,
+        borderRadius: theme.borderRadius.sm,
+        fontSize: theme.fontSize.sm
+      },
+      style
+    ],
+    value,
+    onChangeText,
+    placeholder,
+    placeholderTextColor: theme.colors.textMuted,
+    autoCapitalize: "none",
+    autoCorrect: false
+  });
+}
+function EmptyState({ theme, title, subtitle, style }) {
+  return React.createElement(
+    View2,
+    { style: [styles.emptyState, style] },
+    React.createElement(Text2, {
+      style: { color: theme.colors.textSecondary, fontSize: theme.fontSize.md, textAlign: "center" }
+    }, title),
+    subtitle ? React.createElement(Text2, {
+      style: { color: theme.colors.textMuted, fontSize: theme.fontSize.sm, textAlign: "center", marginTop: 4 }
+    }, subtitle) : null
+  );
+}
+function ErrorState({ theme, message, onRetry, style }) {
+  return React.createElement(
+    View2,
+    { style: [styles.emptyState, style] },
+    React.createElement(Text2, {
+      style: { color: theme.colors.error, fontSize: theme.fontSize.md, textAlign: "center" }
+    }, message),
+    onRetry ? React.createElement(
+      Pressable2,
+      {
+        style: [styles.retryButton, { backgroundColor: theme.colors.accentSoft, borderRadius: theme.borderRadius.sm }],
+        onPress: onRetry
+      },
+      React.createElement(Text2, {
+        style: { color: theme.colors.accent, fontSize: theme.fontSize.sm, fontWeight: "600" }
+      }, "Retry")
+    ) : null
+  );
+}
+function LoadingState({ theme, message = "Loading...", style }) {
+  return React.createElement(
+    View2,
+    { style: [styles.emptyState, style] },
+    React.createElement(ActivityIndicator2, { size: "small", color: theme.colors.accent }),
+    React.createElement(Text2, {
+      style: { color: theme.colors.textSecondary, fontSize: theme.fontSize.sm, marginTop: 8 }
+    }, message)
+  );
+}
+function ActionButton({ theme, label, icon, onPress, style }) {
+  return React.createElement(
+    Pressable2,
+    {
+      style: [
+        styles.fab,
+        { backgroundColor: theme.colors.accent, borderRadius: theme.borderRadius.full },
+        style
+      ],
+      onPress
+    },
+    icon || React.createElement(Text2, { style: styles.fabText }, label || "+")
+  );
+}
+var styles = StyleSheet2.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: StyleSheet2.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
+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: () => {
+  }, 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")
+};
+var _pluginNative = noopNative;
+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;
+}
+var _cameraPreview = null;
+function setCameraPreviewProvider(Component) {
+  _cameraPreview = Component;
+}
+function getCameraPreviewProvider() {
+  return _cameraPreview;
+}
+var _nativeRegistry = /* @__PURE__ */ new Map();
+function registerNativePlugin(id, plugin) {
+  _nativeRegistry.set(id, plugin);
+}
+function unregisterNativePlugin(id) {
+  _nativeRegistry.delete(id);
+}
+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;
+      }
+    }
+    return entry;
+  }
+};
+var _bundleModules = /* @__PURE__ */ new Map();
+function registerBundleModules(modules) {
+  for (const [name, mod] of Object.entries(modules)) {
+    _bundleModules.set(name, mod);
+  }
+}
+function resolveBundleModule(name) {
+  return _bundleModules.get(name);
+}
+
+// src/sdk/CameraPreview.tsx
+import { jsx } from "react/jsx-runtime";
+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__ */ jsx(Provider, { facing, style, renderUnavailable });
+}
+function unavailable2(reason, render, style) {
+  if (render) return render(reason);
+  return /* @__PURE__ */ jsx(View, { style: [{ flex: 1, backgroundColor: "#000", alignItems: "center", justifyContent: "center", padding: 20 }, style], children: /* @__PURE__ */ jsx(Text, { style: { color: "#39FF66", fontSize: 12, textAlign: "center" }, children: `NO CAMERA PREVIEW
+${reason}` }) });
+}
+
+// src/sdk/usePluginTheme.ts
+import { useMemo, useSyncExternalStore } from "react";
+import { useColorScheme } from "react-native";
+import { ada, spacing, fontSize, borderRadius } from "@ateam-ai-mobile/core";
+var adaColors = {
+  bg: ada.paper,
+  surface: ada.paperSoft,
+  surfaceAlt: ada.paperDeep,
+  input: ada.paper,
+  border: ada.border,
+  text: ada.ink,
+  textSecondary: ada.inkSoft,
+  textMuted: ada.inkMuted,
+  accent: ada.orange,
+  accentSoft: 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: ada.orangeDeep,
+  purpleSoft: 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;
+  _subscribers.forEach((fn) => fn());
+}
+function subscribe(fn) {
+  _subscribers.add(fn);
+  return () => {
+    _subscribers.delete(fn);
+  };
+}
+function usePluginTheme() {
+  const colors = useSyncExternalStore(subscribe, () => _colors);
+  const hostIsDark = useSyncExternalStore(subscribe, () => _isDark);
+  const scheme = useColorScheme();
+  const isDark = hostIsDark ?? scheme === "dark";
+  return useMemo(() => ({
+    colors,
+    spacing: {
+      xs: spacing.xs,
+      sm: spacing.sm,
+      md: spacing.md,
+      lg: spacing.lg,
+      xl: spacing.xl,
+      xxl: spacing.xxl
+    },
+    fontSize: {
+      xs: fontSize.xs,
+      sm: fontSize.sm,
+      md: fontSize.md,
+      lg: fontSize.lg,
+      xl: fontSize.xl
+    },
+    borderRadius: {
+      sm: borderRadius.sm,
+      md: borderRadius.md,
+      lg: borderRadius.lg,
+      full: borderRadius.full
+    },
+    isDark
+  }), [colors, isDark]);
+}
+
+// src/sdk/useApi.ts
+import { useMemo as useMemo2 } from "react";
+function useApi(bridge) {
+  return useMemo2(() => {
+    const apiFn = async (connectorId, tool, args = {}) => {
+      if (!bridge) {
+        throw new Error("useApi: bridge is required. Pass it from plugin props.");
+      }
+      return bridge.mcpCall(tool, args, connectorId);
+    };
+    const callMethod = async (first, second, third) => {
+      if (!bridge) {
+        throw new Error("useApi: bridge is required. Pass it from plugin props.");
+      }
+      if (typeof second === "string") {
+        return bridge.mcpCall(second, third || {}, first);
+      }
+      if (typeof third === "string") {
+        return bridge.mcpCall(first, second || {}, third);
+      }
+      return bridge.mcpCall(first, second || {});
+    };
+    Object.defineProperty(apiFn, "call", {
+      value: callMethod,
+      writable: false,
+      configurable: false
+    });
+    return apiFn;
+  }, [bridge]);
+}
+
+// src/sdk/index.ts
+var PluginSDK = { register, registerService, registerTools };
+
+// src/surfaces/SurfaceDrawer.tsx
+import { useEffect as useEffect2, useRef } from "react";
+import {
+  View as View4,
+  Text as Text3,
+  Pressable as Pressable3,
+  StyleSheet as StyleSheet4,
+  Animated as Animated3,
+  Dimensions,
+  Platform as Platform2
+} from "react-native";
+import Svg2, { Path } from "react-native-svg";
+import { ada as ada2 } from "@ateam-ai-mobile/core";
+
+// src/surfaces/AdaOrb.tsx
+import { useEffect } from "react";
+import { View as View3, StyleSheet as StyleSheet3 } from "react-native";
+import Animated2, {
+  useSharedValue,
+  useAnimatedProps,
+  withRepeat,
+  withTiming,
+  withSequence,
+  Easing,
+  cancelAnimation
+} from "react-native-reanimated";
+import Svg, { Circle, Defs, RadialGradient, Stop, Text as SvgText } from "react-native-svg";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var AnimatedCircle = Animated2.createAnimatedComponent(Circle);
+function AdaOrb({ size = 120, state = "idle", inscription = true }) {
+  const showInscription = inscription && size >= 60;
+  const center = size / 2;
+  const coreR = size * 0.32;
+  const innerHaloR = size * 0.42;
+  const outerHaloR = size * 0.5;
+  const coreScale = useSharedValue(1);
+  const innerScale = useSharedValue(1);
+  const outerScale = useSharedValue(1);
+  const outerOpacity = useSharedValue(0.55);
+  const rippleCycle = useSharedValue(0);
+  const orbit1 = useSharedValue(0);
+  const orbit2 = useSharedValue(0);
+  const orbit3 = useSharedValue(0);
+  const beat = useSharedValue(1);
+  useEffect(() => {
+    cancelAnimation(coreScale);
+    cancelAnimation(innerScale);
+    cancelAnimation(outerScale);
+    cancelAnimation(outerOpacity);
+    cancelAnimation(rippleCycle);
+    cancelAnimation(orbit1);
+    cancelAnimation(orbit2);
+    cancelAnimation(orbit3);
+    cancelAnimation(beat);
+    rippleCycle.value = 0;
+    orbit1.value = 0;
+    orbit2.value = 0;
+    orbit3.value = 0;
+    beat.value = 1;
+    let breathMs = 3600;
+    let breathAmount = 0.025;
+    if (state === "listening") {
+      breathMs = 2e3;
+      breathAmount = 0.05;
+      rippleCycle.value = withRepeat(
+        withTiming(1, { duration: 2e3, easing: Easing.out(Easing.quad) }),
+        -1,
+        false
+      );
+    } else if (state === "thinking") {
+      breathMs = 2400;
+      breathAmount = 0.04;
+      orbit1.value = withRepeat(
+        withTiming(1, { duration: 1100, easing: Easing.linear }),
+        -1,
+        false
+      );
+      orbit2.value = withRepeat(
+        withTiming(1, { duration: 1900, easing: Easing.linear }),
+        -1,
+        false
+      );
+      orbit3.value = withRepeat(
+        withTiming(-1, { duration: 2700, easing: Easing.linear }),
+        -1,
+        false
+      );
+    } else if (state === "speaking") {
+      breathMs = 700;
+      breathAmount = 0.13;
+      beat.value = withRepeat(
+        withSequence(
+          withTiming(1.08, { duration: 90, easing: Easing.out(Easing.quad) }),
+          withTiming(1, { duration: 130, easing: Easing.in(Easing.quad) }),
+          withTiming(1.05, { duration: 80, easing: Easing.out(Easing.quad) }),
+          withTiming(1, { duration: 200, easing: Easing.in(Easing.quad) }),
+          withTiming(1, { duration: 280 })
+        ),
+        -1,
+        false
+      );
+    }
+    const breathEasing = state === "speaking" ? Easing.out(Easing.cubic) : Easing.inOut(Easing.sin);
+    coreScale.value = withRepeat(
+      withSequence(
+        withTiming(1 + breathAmount, { duration: breathMs, easing: breathEasing }),
+        withTiming(1, { duration: breathMs, easing: breathEasing })
+      ),
+      -1,
+      false
+    );
+    innerScale.value = withRepeat(
+      withSequence(
+        withTiming(1 + breathAmount * 1.4, { duration: breathMs * 1.15, easing: breathEasing }),
+        withTiming(1, { duration: breathMs * 1.15, easing: breathEasing })
+      ),
+      -1,
+      false
+    );
+    outerScale.value = withRepeat(
+      withSequence(
+        withTiming(1 + breathAmount * 1.8, { duration: breathMs * 1.3, easing: breathEasing }),
+        withTiming(1, { duration: breathMs * 1.3, easing: breathEasing })
+      ),
+      -1,
+      false
+    );
+    outerOpacity.value = withRepeat(
+      withSequence(
+        withTiming(state === "idle" ? 0.55 : 0.8, { duration: breathMs * 1.3, easing: breathEasing }),
+        withTiming(0.35, { duration: breathMs * 1.3, easing: breathEasing })
+      ),
+      -1,
+      false
+    );
+  }, [state]);
+  const coreProps = useAnimatedProps(() => ({
+    r: coreR * coreScale.value * beat.value
+  }));
+  const innerProps = useAnimatedProps(() => ({
+    r: innerHaloR * innerScale.value * beat.value
+  }));
+  const outerProps = useAnimatedProps(() => ({
+    r: outerHaloR * outerScale.value,
+    opacity: outerOpacity.value
+  }));
+  const ripple1Props = useAnimatedProps(() => {
+    const t = rippleCycle.value;
+    return {
+      r: outerHaloR * (1 + t * 0.55),
+      opacity: state === "listening" ? 0.55 * (1 - t) : 0
+    };
+  });
+  const ripple2Props = useAnimatedProps(() => {
+    const t = (rippleCycle.value + 0.34) % 1;
+    return {
+      r: outerHaloR * (1 + t * 0.55),
+      opacity: state === "listening" ? 0.45 * (1 - t) : 0
+    };
+  });
+  const ripple3Props = useAnimatedProps(() => {
+    const t = (rippleCycle.value + 0.67) % 1;
+    return {
+      r: outerHaloR * (1 + t * 0.55),
+      opacity: state === "listening" ? 0.35 * (1 - t) : 0
+    };
+  });
+  const spark1Props = useAnimatedProps(() => {
+    const angle = orbit1.value * Math.PI * 2 - Math.PI / 2;
+    const r = coreR * 0.55;
+    return {
+      cx: center + Math.cos(angle) * r,
+      cy: center + Math.sin(angle) * r,
+      opacity: state === "thinking" ? 1 : 0
+    };
+  });
+  const spark2Props = useAnimatedProps(() => {
+    const angle = orbit2.value * Math.PI * 2 + Math.PI * 0.6;
+    const r = coreR * 0.85;
+    return {
+      cx: center + Math.cos(angle) * r,
+      cy: center + Math.sin(angle) * r,
+      opacity: state === "thinking" ? 0.9 : 0
+    };
+  });
+  const spark3Props = useAnimatedProps(() => {
+    const angle = orbit3.value * Math.PI * 2 + Math.PI * 1.3;
+    const r = coreR * 1.05;
+    return {
+      cx: center + Math.cos(angle) * r,
+      cy: center + Math.sin(angle) * r,
+      opacity: state === "thinking" ? 0.7 : 0
+    };
+  });
+  return /* @__PURE__ */ jsx2(View3, { style: [styles2.wrap, { width: size, height: size }], children: /* @__PURE__ */ jsxs(Svg, { width: size, height: size, children: [
+    /* @__PURE__ */ jsxs(Defs, { children: [
+      /* @__PURE__ */ jsxs(RadialGradient, { id: "adaCore", cx: "36%", cy: "30%", r: "70%", children: [
+        /* @__PURE__ */ jsx2(Stop, { offset: "0%", stopColor: "#FFE0B0", stopOpacity: "1" }),
+        /* @__PURE__ */ jsx2(Stop, { offset: "28%", stopColor: "#FFA85A", stopOpacity: "1" }),
+        /* @__PURE__ */ jsx2(Stop, { offset: "65%", stopColor: "#FF7A28", stopOpacity: "1" }),
+        /* @__PURE__ */ jsx2(Stop, { offset: "100%", stopColor: "#B8410A", stopOpacity: "1" })
+      ] }),
+      /* @__PURE__ */ jsxs(RadialGradient, { id: "adaInner", cx: "50%", cy: "50%", r: "50%", children: [
+        /* @__PURE__ */ jsx2(Stop, { offset: "0%", stopColor: "#FF8A3C", stopOpacity: "0.55" }),
+        /* @__PURE__ */ jsx2(Stop, { offset: "100%", stopColor: "#FF7028", stopOpacity: "0" })
+      ] }),
+      /* @__PURE__ */ jsxs(RadialGradient, { id: "adaOuter", cx: "50%", cy: "50%", r: "50%", children: [
+        /* @__PURE__ */ jsx2(Stop, { offset: "0%", stopColor: "#FF7A28", stopOpacity: "0.4" }),
+        /* @__PURE__ */ jsx2(Stop, { offset: "100%", stopColor: "#FF6018", stopOpacity: "0" })
+      ] }),
+      /* @__PURE__ */ jsxs(RadialGradient, { id: "adaSpark", cx: "50%", cy: "50%", r: "50%", children: [
+        /* @__PURE__ */ jsx2(Stop, { offset: "0%", stopColor: "#FFFAEB", stopOpacity: "1" }),
+        /* @__PURE__ */ jsx2(Stop, { offset: "60%", stopColor: "#FFD095", stopOpacity: "0.9" }),
+        /* @__PURE__ */ jsx2(Stop, { offset: "100%", stopColor: "#FFA85A", stopOpacity: "0" })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx2(
+      AnimatedCircle,
+      {
+        cx: center,
+        cy: center,
+        stroke: "#FF7A28",
+        strokeWidth: 1.5,
+        fill: "none",
+        animatedProps: ripple1Props
+      }
+    ),
+    /* @__PURE__ */ jsx2(
+      AnimatedCircle,
+      {
+        cx: center,
+        cy: center,
+        stroke: "#FF7A28",
+        strokeWidth: 1.5,
+        fill: "none",
+        animatedProps: ripple2Props
+      }
+    ),
+    /* @__PURE__ */ jsx2(
+      AnimatedCircle,
+      {
+        cx: center,
+        cy: center,
+        stroke: "#FF7A28",
+        strokeWidth: 1.5,
+        fill: "none",
+        animatedProps: ripple3Props
+      }
+    ),
+    /* @__PURE__ */ jsx2(AnimatedCircle, { cx: center, cy: center, fill: "url(#adaOuter)", animatedProps: outerProps }),
+    /* @__PURE__ */ jsx2(AnimatedCircle, { cx: center, cy: center, fill: "url(#adaInner)", animatedProps: innerProps }),
+    /* @__PURE__ */ jsx2(AnimatedCircle, { cx: center, cy: center, fill: "url(#adaCore)", animatedProps: coreProps }),
+    /* @__PURE__ */ jsx2(
+      AnimatedCircle,
+      {
+        r: Math.max(3, size * 0.05),
+        fill: "url(#adaSpark)",
+        animatedProps: spark1Props
+      }
+    ),
+    /* @__PURE__ */ jsx2(
+      AnimatedCircle,
+      {
+        r: Math.max(2.5, size * 0.04),
+        fill: "url(#adaSpark)",
+        animatedProps: spark2Props
+      }
+    ),
+    /* @__PURE__ */ jsx2(
+      AnimatedCircle,
+      {
+        r: Math.max(2, size * 0.032),
+        fill: "url(#adaSpark)",
+        animatedProps: spark3Props
+      }
+    ),
+    showInscription && /* @__PURE__ */ jsx2(
+      SvgText,
+      {
+        x: center,
+        y: center + size * 0.11,
+        fontSize: size * 0.34,
+        fontWeight: "600",
+        fill: "#FFF5E0",
+        textAnchor: "middle",
+        letterSpacing: -size * 5e-3,
+        children: "iA"
+      }
+    )
+  ] }) });
+}
+var styles2 = StyleSheet3.create({
+  wrap: {
+    alignItems: "center",
+    justifyContent: "center"
+  }
+});
+
+// src/surfaces/SurfaceDrawer.tsx
+import { jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var SCREEN_H = Dimensions.get("window").height;
+var fontFam = Platform2.OS === "ios" ? "SF Pro Rounded" : void 0;
+function SurfaceDrawer({
+  visible,
+  onClose,
+  title,
+  subtitle,
+  privacy,
+  showOrb = true,
+  heightRatio = 0.85,
+  children
+}) {
+  const sheetH = Math.round(SCREEN_H * heightRatio);
+  const fadeAnim = useRef(new Animated3.Value(0)).current;
+  const slideAnim = useRef(new Animated3.Value(sheetH)).current;
+  useEffect2(() => {
+    if (visible) {
+      Animated3.parallel([
+        Animated3.timing(fadeAnim, { toValue: 1, duration: 220, useNativeDriver: true }),
+        Animated3.spring(slideAnim, { toValue: 0, useNativeDriver: true, tension: 80, friction: 12 })
+      ]).start();
+    } else {
+      fadeAnim.setValue(0);
+      slideAnim.setValue(sheetH);
+    }
+  }, [visible]);
+  const close = () => {
+    Animated3.parallel([
+      Animated3.timing(fadeAnim, { toValue: 0, duration: 160, useNativeDriver: true }),
+      Animated3.timing(slideAnim, { toValue: sheetH, duration: 200, useNativeDriver: true })
+    ]).start(() => onClose());
+  };
+  if (!visible) return null;
+  return /* @__PURE__ */ jsxs2(Animated3.View, { style: [styles3.overlay, { opacity: fadeAnim }], pointerEvents: "auto", children: [
+    /* @__PURE__ */ jsx3(Pressable3, { style: StyleSheet4.absoluteFill, onPress: close }),
+    /* @__PURE__ */ jsxs2(
+      Animated3.View,
+      {
+        style: [
+          styles3.sheet,
+          { height: sheetH, transform: [{ translateY: slideAnim }] }
+        ],
+        children: [
+          /* @__PURE__ */ jsx3(View4, { style: styles3.handle }),
+          /* @__PURE__ */ jsxs2(View4, { style: styles3.header, children: [
+            showOrb ? /* @__PURE__ */ jsx3(View4, { style: styles3.headerOrb, children: /* @__PURE__ */ jsx3(AdaOrb, { size: 36, state: "idle" }) }) : null,
+            /* @__PURE__ */ jsxs2(View4, { style: { flex: 1 }, children: [
+              /* @__PURE__ */ jsx3(Text3, { style: styles3.title, children: title }),
+              subtitle ? /* @__PURE__ */ jsx3(Text3, { style: styles3.subtitle, children: subtitle }) : null,
+              privacy ? /* @__PURE__ */ jsxs2(View4, { style: styles3.privacyPill, children: [
+                /* @__PURE__ */ jsxs2(Svg2, { width: 11, height: 11, viewBox: "0 0 24 24", fill: "none", stroke: ada2.inkSoft, strokeWidth: 2.5, strokeLinecap: "round", strokeLinejoin: "round", children: [
+                  /* @__PURE__ */ jsx3(Path, { d: "M19 11H5a2 2 0 00-2 2v7a2 2 0 002 2h14a2 2 0 002-2v-7a2 2 0 00-2-2z" }),
+                  /* @__PURE__ */ jsx3(Path, { d: "M7 11V7a5 5 0 0110 0v4" })
+                ] }),
+                /* @__PURE__ */ jsx3(Text3, { style: styles3.privacyText, children: "Only you can see this" })
+              ] }) : null
+            ] }),
+            /* @__PURE__ */ jsx3(
+              Pressable3,
+              {
+                accessibilityRole: "button",
+                accessibilityLabel: "Close",
+                style: styles3.closeBtn,
+                onPress: close,
+                hitSlop: 12,
+                children: /* @__PURE__ */ jsx3(Svg2, { width: 18, height: 18, viewBox: "0 0 24 24", fill: "none", stroke: ada2.inkSoft, strokeWidth: 2.2, strokeLinecap: "round", children: /* @__PURE__ */ jsx3(Path, { d: "M18 6L6 18M6 6l12 12" }) })
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx3(View4, { style: styles3.body, children })
+        ]
+      }
+    )
+  ] });
+}
+var styles3 = StyleSheet4.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: ada2.paper,
+    borderTopLeftRadius: 28,
+    borderTopRightRadius: 28,
+    overflow: "hidden"
+  },
+  handle: {
+    width: 40,
+    height: 4,
+    borderRadius: 2,
+    backgroundColor: ada2.inkMuted,
+    opacity: 0.3,
+    alignSelf: "center",
+    marginTop: 10,
+    marginBottom: 6
+  },
+  header: {
+    flexDirection: "row",
+    alignItems: "center",
+    paddingHorizontal: 22,
+    paddingVertical: 16,
+    gap: 12,
+    borderBottomWidth: 1,
+    borderBottomColor: ada2.border
+  },
+  headerOrb: {
+    width: 36,
+    height: 36,
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  title: {
+    fontSize: 17,
+    fontWeight: "600",
+    color: ada2.ink,
+    letterSpacing: -0.2,
+    fontFamily: fontFam
+  },
+  subtitle: {
+    fontSize: 13,
+    fontWeight: "400",
+    color: ada2.inkSoft,
+    marginTop: 2,
+    letterSpacing: -0.1,
+    fontFamily: fontFam
+  },
+  privacyPill: {
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 5,
+    marginTop: 4
+  },
+  privacyText: {
+    fontSize: 11,
+    fontWeight: "500",
+    color: ada2.inkSoft,
+    letterSpacing: 0.2,
+    fontFamily: fontFam
+  },
+  closeBtn: {
+    width: 32,
+    height: 32,
+    borderRadius: 16,
+    backgroundColor: ada2.paperSoft,
+    justifyContent: "center",
+    alignItems: "center"
+  },
+  body: {
+    flex: 1
+  }
+});
+
+// src/surfaces/SurfaceCard.tsx
+import {
+  View as View5,
+  Text as Text4,
+  Pressable as Pressable4,
+  StyleSheet as StyleSheet5,
+  Platform as Platform3
+} from "react-native";
+import { ada as ada3, borderRadius as borderRadius2 } from "@ateam-ai-mobile/core";
+import { jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+var fontFam2 = Platform3.OS === "ios" ? "SF Pro Rounded" : void 0;
+function SurfaceCard({
+  icon,
+  title,
+  subtitle,
+  onPress,
+  onLongPress,
+  showArrow,
+  children
+}) {
+  const arrow = showArrow ?? !!onPress;
+  const handlePress = () => {
+    if (!onPress) return;
+    getHaptics()?.impact("light");
+    onPress();
+  };
+  const handleLongPress = () => {
+    if (!onLongPress) return;
+    getHaptics()?.impact("medium");
+    onLongPress();
+  };
+  return /* @__PURE__ */ jsxs3(
+    Pressable4,
+    {
+      accessibilityRole: "button",
+      accessibilityLabel: [icon, title, subtitle].filter(Boolean).join(", "),
+      accessibilityHint: onLongPress ? "Long-press for more options" : void 0,
+      style: styles4.card,
+      onPress: onPress ? handlePress : void 0,
+      onLongPress: onLongPress ? handleLongPress : void 0,
+      disabled: !onPress && !onLongPress,
+      children: [
+        /* @__PURE__ */ jsxs3(View5, { style: styles4.row, children: [
+          icon ? /* @__PURE__ */ jsx4(Text4, { style: styles4.icon, children: icon }) : null,
+          /* @__PURE__ */ jsxs3(View5, { style: { flex: 1 }, children: [
+            /* @__PURE__ */ jsx4(Text4, { style: styles4.title, children: title }),
+            subtitle ? /* @__PURE__ */ jsx4(Text4, { style: styles4.subtitle, children: subtitle }) : null
+          ] }),
+          arrow ? /* @__PURE__ */ jsx4(Text4, { style: styles4.arrow, children: "\u2192" }) : null
+        ] }),
+        children ? /* @__PURE__ */ jsx4(View5, { style: styles4.body, children }) : null
+      ]
+    }
+  );
+}
+var styles4 = StyleSheet5.create({
+  card: {
+    backgroundColor: ada3.paperSoft,
+    borderWidth: 1,
+    borderColor: ada3.border,
+    borderRadius: borderRadius2.xl,
+    paddingHorizontal: 16,
+    paddingVertical: 14
+  },
+  row: {
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 14
+  },
+  icon: {
+    fontSize: 22
+  },
+  title: {
+    fontSize: 15,
+    fontWeight: "600",
+    color: ada3.ink,
+    letterSpacing: -0.2,
+    fontFamily: fontFam2
+  },
+  subtitle: {
+    fontSize: 13,
+    fontWeight: "400",
+    color: ada3.inkMuted,
+    marginTop: 2,
+    letterSpacing: -0.1,
+    fontFamily: fontFam2
+  },
+  arrow: {
+    fontSize: 18,
+    color: ada3.inkMuted,
+    fontWeight: "400"
+  },
+  body: {
+    marginTop: 10,
+    paddingTop: 10,
+    borderTopWidth: 1,
+    borderTopColor: ada3.border
+  }
+});
+
+// src/surfaces/SurfaceFullscreen.tsx
+import { useEffect as useEffect3, useRef as useRef2 } from "react";
+import {
+  View as View6,
+  Text as Text5,
+  Pressable as Pressable5,
+  StyleSheet as StyleSheet6,
+  Animated as Animated4,
+  Platform as Platform4
+} from "react-native";
+import Svg3, { Path as Path2 } from "react-native-svg";
+import { ada as ada4 } from "@ateam-ai-mobile/core";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var fontFam3 = Platform4.OS === "ios" ? "SF Pro Rounded" : void 0;
+function SurfaceFullscreen({
+  visible,
+  onClose,
+  status,
+  hero,
+  children,
+  showWordmark = true,
+  closeIcon = "x",
+  closeLabel = "Close"
+}) {
+  const fadeAnim = useRef2(new Animated4.Value(0)).current;
+  const heroScale = useRef2(new Animated4.Value(0.6)).current;
+  useEffect3(() => {
+    if (visible) {
+      Animated4.parallel([
+        Animated4.timing(fadeAnim, { toValue: 1, duration: 280, useNativeDriver: true }),
+        Animated4.spring(heroScale, { toValue: 1, useNativeDriver: true, tension: 60, friction: 11 })
+      ]).start();
+    } else {
+      fadeAnim.setValue(0);
+      heroScale.setValue(0.6);
+    }
+  }, [visible]);
+  const close = () => {
+    Animated4.parallel([
+      Animated4.timing(fadeAnim, { toValue: 0, duration: 180, useNativeDriver: true }),
+      Animated4.timing(heroScale, { toValue: 0.6, duration: 180, useNativeDriver: true })
+    ]).start(() => onClose());
+  };
+  if (!visible) return null;
+  const renderCloseIcon = () => {
+    if (closeIcon === "hangup") {
+      return /* @__PURE__ */ jsx5(Svg3, { width: 22, height: 22, viewBox: "0 0 24 24", fill: ada4.paper, children: /* @__PURE__ */ jsx5(Path2, { 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__ */ jsx5(Svg3, { width: 20, height: 20, viewBox: "0 0 24 24", fill: "none", stroke: ada4.paper, strokeWidth: 2.5, strokeLinecap: "round", children: /* @__PURE__ */ jsx5(Path2, { d: "M18 6L6 18M6 6l12 12" }) });
+    }
+    return closeIcon;
+  };
+  return /* @__PURE__ */ jsxs4(Animated4.View, { style: [styles5.overlay, { opacity: fadeAnim }], pointerEvents: "auto", children: [
+    /* @__PURE__ */ jsxs4(View6, { style: styles5.topBar, children: [
+      showWordmark ? /* @__PURE__ */ jsx5(Text5, { style: styles5.wordmark, children: "ada" }) : null,
+      status ? /* @__PURE__ */ jsx5(Text5, { style: styles5.status, children: status }) : null
+    ] }),
+    hero ? /* @__PURE__ */ jsx5(View6, { style: styles5.heroWrap, children: /* @__PURE__ */ jsx5(Animated4.View, { style: { transform: [{ scale: heroScale }] }, children: hero }) }) : null,
+    /* @__PURE__ */ jsx5(View6, { style: styles5.body, children }),
+    /* @__PURE__ */ jsxs4(View6, { style: styles5.bottomBar, children: [
+      /* @__PURE__ */ jsx5(
+        Pressable5,
+        {
+          accessibilityRole: "button",
+          accessibilityLabel: closeLabel,
+          style: styles5.closeBtn,
+          onPress: close,
+          hitSlop: 12,
+          children: renderCloseIcon()
+        }
+      ),
+      closeLabel ? /* @__PURE__ */ jsx5(Text5, { style: styles5.closeLabel, children: closeLabel }) : null
+    ] })
+  ] });
+}
+var styles5 = StyleSheet6.create({
+  overlay: {
+    position: "absolute",
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0,
+    backgroundColor: ada4.paper,
+    zIndex: 1e3,
+    elevation: 1e3
+  },
+  topBar: {
+    paddingTop: Platform4.OS === "ios" ? 64 : 36,
+    paddingHorizontal: 24,
+    alignItems: "center",
+    gap: 6
+  },
+  wordmark: {
+    fontSize: 14,
+    fontFamily: fontFam3,
+    fontWeight: "500",
+    color: ada4.inkMuted,
+    letterSpacing: 4
+  },
+  status: {
+    fontSize: 17,
+    fontFamily: fontFam3,
+    fontWeight: "500",
+    color: ada4.ink,
+    letterSpacing: -0.2
+  },
+  heroWrap: {
+    paddingTop: 24,
+    paddingBottom: 12,
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  body: {
+    flex: 1
+  },
+  bottomBar: {
+    paddingBottom: Platform4.OS === "ios" ? 48 : 32,
+    paddingTop: 12,
+    alignItems: "center",
+    gap: 8
+  },
+  closeBtn: {
+    width: 64,
+    height: 64,
+    borderRadius: 32,
+    backgroundColor: ada4.ink,
+    justifyContent: "center",
+    alignItems: "center",
+    shadowColor: ada4.ink,
+    shadowOffset: { width: 0, height: 8 },
+    shadowOpacity: 0.18,
+    shadowRadius: 14,
+    elevation: 8
+  },
+  closeLabel: {
+    fontSize: 13,
+    fontFamily: fontFam3,
+    fontWeight: "500",
+    color: ada4.inkMuted,
+    letterSpacing: 0.3
+  }
+});
+
+// src/registry/store.ts
+import { create } from "zustand";
+var useSurfaceStore = 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";
+}
+
+// src/registry/SurfaceDispatcher.tsx
+import { useEffect as useEffect4 } from "react";
+import { pluginCommandEmitter } from "@ateam-ai-mobile/core";
+import { Fragment, jsx as jsx6, jsxs as jsxs5 } from "react/jsx-runtime";
+function SurfaceDispatcher() {
+  const manifests = useSurfaceStore((s) => s.manifests);
+  const activeDrawer = useSurfaceStore((s) => s.activeDrawer);
+  const activeFullscreen = useSurfaceStore((s) => s.activeFullscreen);
+  const activeProps = useSurfaceStore((s) => s.activeProps);
+  const mountKey = useSurfaceStore((s) => s.mountKey);
+  const hide = useSurfaceStore((s) => s.hide);
+  useEffect4(() => {
+    const unsub = pluginCommandEmitter.on("plugin-close", ({ pluginId } = {}) => {
+      if (!pluginId) return;
+      const s = useSurfaceStore.getState();
+      if (s.activeDrawer === pluginId || s.activeFullscreen === pluginId) {
+        s.hide(pluginId);
+      }
+    });
+    return unsub;
+  }, []);
+  const drawer = activeDrawer ? manifests[activeDrawer] : null;
+  const fullscreen = activeFullscreen ? manifests[activeFullscreen] : null;
+  const drawerProps = activeDrawer ? activeProps[activeDrawer] : void 0;
+  const fullscreenProps = activeFullscreen ? activeProps[activeFullscreen] : void 0;
+  return /* @__PURE__ */ jsxs5(Fragment, { children: [
+    drawer && drawer.type === "drawer" && drawer.Component ? /* @__PURE__ */ jsx6(
+      drawer.Component,
+      {
+        dismiss: () => hide(drawer.id),
+        props: drawerProps
+      },
+      `drawer-${drawer.id}-${mountKey}`
+    ) : null,
+    fullscreen && fullscreen.type === "fullscreen" && fullscreen.Component ? /* @__PURE__ */ jsx6(
+      fullscreen.Component,
+      {
+        dismiss: () => hide(fullscreen.id),
+        props: fullscreenProps
+      },
+      `fullscreen-${fullscreen.id}-${mountKey}`
+    ) : null
+  ] });
+}
+
+// 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);
+  for (let i = 0; i < utf8.length; i++) bytes[i] = utf8.charCodeAt(i);
+  const bitLen = bytes.length * 8;
+  const padLen = (56 - (bytes.length + 1) % 64 + 64) % 64;
+  const buf = new Uint8Array(bytes.length + 1 + padLen + 8);
+  buf.set(bytes);
+  buf[bytes.length] = 128;
+  const len = buf.length;
+  buf[len - 4] = bitLen >>> 24 & 255;
+  buf[len - 3] = bitLen >>> 16 & 255;
+  buf[len - 2] = bitLen >>> 8 & 255;
+  buf[len - 1] = bitLen & 255;
+  const h = new Uint32Array([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  const w = new Uint32Array(64);
+  for (let i = 0; i < buf.length; i += 64) {
+    for (let t = 0; t < 16; t++) {
+      const j = i + t * 4;
+      w[t] = buf[j] << 24 | buf[j + 1] << 16 | buf[j + 2] << 8 | buf[j + 3];
+    }
+    for (let t = 16; t < 64; t++) {
+      const s0 = rotr(7, w[t - 15]) ^ rotr(18, w[t - 15]) ^ w[t - 15] >>> 3;
+      const s1 = rotr(17, w[t - 2]) ^ rotr(19, w[t - 2]) ^ w[t - 2] >>> 10;
+      w[t] = w[t - 16] + s0 + w[t - 7] + s1 | 0;
+    }
+    let a = h[0], b = h[1], c = h[2], d = h[3], e = h[4], f = h[5], g = h[6], hh = h[7];
+    for (let t = 0; t < 64; t++) {
+      const S1 = rotr(6, e) ^ rotr(11, e) ^ rotr(25, e);
+      const ch = e & f ^ ~e & g;
+      const temp1 = hh + S1 + ch + K[t] + w[t] | 0;
+      const S0 = rotr(2, a) ^ rotr(13, a) ^ rotr(22, a);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = S0 + maj | 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + temp1 | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 | 0;
+    }
+    h[0] = h[0] + a | 0;
+    h[1] = h[1] + b | 0;
+    h[2] = h[2] + c | 0;
+    h[3] = h[3] + d | 0;
+    h[4] = h[4] + e | 0;
+    h[5] = h[5] + f | 0;
+    h[6] = h[6] + g | 0;
+    h[7] = h[7] + hh | 0;
+  }
+  let out = "";
+  for (let i = 0; i < 8; i++) {
+    out += h[i].toString(16).padStart(8, "0");
+  }
+  return out;
+}
+
+// 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).`);
+  }
+  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.`
+    );
+  }
+}
+
+// src/bundles/storage.ts
+function selectOwnedCacheEntries(entries, tenant) {
+  if (!tenant) return [];
+  return (entries || []).filter((e) => !!e && e.tenant === tenant);
+}
+var 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();
+  }
+};
+var _storage = new MemoryBundleStorage();
+function setBundleStorage(storage) {
+  _storage = storage;
+}
+function getBundleStorage() {
+  return _storage;
+}
+
+// src/bridge/native.ts
+import { useCallback, useMemo as useMemo3, useRef as useRef3, useEffect as useEffect5 } from "react";
+import {
+  connectorCall,
+  mcpFetch as mcpFetchApi,
+  unwrapMcpResult,
+  postCommandResult,
+  getTenant,
+  getUser,
+  pluginCommandEmitter as pluginCommandEmitter2,
+  useChatStore
+} from "@ateam-ai-mobile/core";
+function buildContext(pluginId, connectorId) {
+  const user = getUser();
+  return {
+    tenant: getTenant(),
+    pluginId,
+    connectorId,
+    user: user ? { id: user.actorId || "", name: user.name || "", roles: user.roles || [] } : void 0
+  };
+}
+function useNativeBridge(pluginId, connectorId, commandBufferRef) {
+  const initCallbackRef = useRef3(null);
+  const commandListenersRef = useRef3(/* @__PURE__ */ new Set());
+  const initializedRef = useRef3(false);
+  const fireInit = useCallback(() => {
+    if (initializedRef.current || !initCallbackRef.current) return;
+    initCallbackRef.current(buildContext(pluginId, connectorId));
+    initializedRef.current = true;
+  }, [pluginId, connectorId]);
+  const onInit = useCallback((cb) => {
+    initCallbackRef.current = cb;
+    setTimeout(fireInit, 0);
+  }, [fireInit]);
+  const mcpCall = 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 connectorCall(targetConnector, tool, args);
+      if (!data.ok && data.error) {
+        throw new Error(data.error);
+      }
+      return 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 = useCallback(async (body) => {
+    return mcpFetchApi(body);
+  }, []);
+  const sendCommand = useCallback((type, payload) => {
+    if (type === "plugin.command.result" && payload?.correlationId) {
+      postCommandResult(payload.correlationId, payload.result, payload.error);
+      return;
+    }
+  }, [pluginId]);
+  const onCommand = 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 pluginCommandEmitter2.drainPluginCommands(pluginId)) {
+      try {
+        cb(cmd.command, { ...cmd.args, correlationId: cmd.correlationId });
+      } catch {
+      }
+    }
+    return () => {
+      commandListenersRef.current.delete(cb);
+    };
+  }, [pluginId, commandBufferRef]);
+  useEffect5(() => {
+    const unsub = pluginCommandEmitter2.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]);
+  useEffect5(() => {
+    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 pluginCommandEmitter2.drainPluginCommands(pluginId)) {
+        dispatch(cmd);
+      }
+    }, 500);
+    return () => clearTimeout(timer);
+  }, [pluginId, commandBufferRef]);
+  useEffect5(() => {
+    return () => {
+      commandListenersRef.current.clear();
+      initializedRef.current = false;
+    };
+  }, []);
+  const close = useCallback(() => {
+    pluginCommandEmitter2.emit("plugin-close", { pluginId });
+  }, [pluginId]);
+  const sendMessage = useCallback((text) => {
+    const t = (text || "").trim();
+    if (!t) return;
+    try {
+      useChatStore.getState().sendMessage(t);
+    } catch (err) {
+      console.warn("[bridge.sendMessage] failed:", err instanceof Error ? err.message : String(err));
+    }
+  }, []);
+  const prepareMessage = useCallback((text) => {
+    const t = (text || "").trim();
+    if (!t) return;
+    pluginCommandEmitter2.emit("prepare-chat-message", { text: t });
+  }, []);
+  return useMemo3(
+    () => ({ 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 connectorCall(targetConnector, tool, args);
+      if (!data.ok && data.error) throw new Error(data.error);
+      return unwrapMcpResult(data.result);
+    },
+    async mcpFetch(body) {
+      return mcpFetchApi(body);
+    },
+    sendCommand(_type, _payload) {
+    },
+    onCommand(cb) {
+      commandListeners.add(cb);
+      return () => {
+        commandListeners.delete(cb);
+      };
+    },
+    close() {
+      pluginCommandEmitter2.emit("plugin-close", { pluginId });
+    },
+    sendMessage(text) {
+      const t = (text || "").trim();
+      if (!t) return;
+      try {
+        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;
+      pluginCommandEmitter2.emit("prepare-chat-message", { text: t });
+    }
+  };
+}
+
+// src/deviceStateHost.ts
+var UNKNOWN_QUALITY = {
+  freshness: { state: "unknown", observedAt: null, ageMs: null },
+  confidence: { level: "unknown" }
+};
+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 {
+    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;
+}
+var ALL_DOMAINS = [
+  "spatial",
+  "visual",
+  "activity",
+  "deviceContext",
+  "connectivity",
+  "capability",
+  "environment",
+  "interaction"
+];
+var _provider = {};
+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]);
+}
+
+// src/tools/registry.ts
+var registry = /* @__PURE__ */ new Map();
+var contextProvider = null;
+var DEFAULT_TIMEOUT_MS = 3e4;
+function setDeviceToolContextProvider(fn) {
+  contextProvider = fn;
+}
+function defaultContext(pluginId, capabilities, stateDomains) {
+  return {
+    bridge: createNativeBridge(pluginId),
+    native: gatePluginNative(getPluginNative(), capabilities, pluginId),
+    deviceState: gateDeviceState(stateDomains)
+  };
+}
+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;
+    }
+    registry.set(tool.name, { pluginId, tool, capabilities, stateDomains });
+    accepted.push(tool.name);
+  }
+  if (accepted.length > 0) {
+    console.log(`[deviceTools] ${pluginId} registered: ${accepted.join(", ")}`);
+  }
+  return accepted;
+}
+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();
+}
+
+// src/bundles/bundleManager.ts
+var ReactShim = {
+  __esModule: true,
+  default: React2,
+  ...React2,
+  // Explicitly include hooks (React 19 may not have them as own enumerable props)
+  useState,
+  useEffect: useEffect6,
+  useCallback: useCallback2,
+  useMemo: useMemo4,
+  useRef: useRef4,
+  useContext,
+  useReducer,
+  useLayoutEffect,
+  useImperativeHandle,
+  useDebugValue,
+  createElement: React2.createElement,
+  Fragment: React2.Fragment,
+  Component: React2.Component,
+  PureComponent: React2.PureComponent,
+  createContext: React2.createContext,
+  forwardRef: React2.forwardRef,
+  memo: React2.memo,
+  Children: React2.Children,
+  cloneElement: React2.cloneElement,
+  isValidElement: React2.isValidElement,
+  createRef: React2.createRef,
+  lazy: React2.lazy,
+  Suspense: React2.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 hasComponent = (val) => !!val && typeof val === "object" && typeof val.Component === "function";
+var hasTools = (val) => !!val && typeof val === "object" && Array.isArray(val.tools) && val.tools.length > 0;
+var 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 = getTenant2();
+    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;
+  }
+  /** 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++;
+  }
+  /** 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 || getTenant2() !== 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 });
+    }
+  }
+  // ── 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 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.dropInMemory();
+    this.cacheTenant = null;
+    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 {
+      }
+    }
+  }
+  /**
+   * 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` : ""})`
+    );
+  }
+  /**
+   * 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);
+  }
+  /**
+   * 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)
+      );
+    }
+  }
+  /**
+   * 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);
+    }
+  }
+  /**
+   * 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 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 {
+      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, 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 {
+      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 {
+      }
+    }
+    return materialized;
+  }
+  // ── 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(", ");
+  }
+};
+var bundleManager = new BundleManager();
+
+// src/voiceHost.ts
+var _provider2 = null;
+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."
+  );
+}
+
+// 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 };
+}
+
+// src/tools/loader.ts
+import { getTenant as getTenant3 } from "@ateam-ai-mobile/core";
+var inflight = null;
+var loadedOnce = false;
+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 [];
+      }
+      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 = getTenant3();
+    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 {
+        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;
+}
+
+export {
+  __export,
+  register,
+  registerTools,
+  registerService,
+  PLATFORM_VOICE_CALLER,
+  View,
+  Text,
+  ScrollView,
+  FlatList,
+  SectionList,
+  Pressable,
+  TouchableOpacity,
+  TextInput,
+  Image,
+  ActivityIndicator,
+  Modal,
+  Switch,
+  StyleSheet,
+  Animated,
+  Platform,
+  RefreshControl,
+  Card,
+  Badge,
+  TabBar,
+  ListItem,
+  SearchBar,
+  EmptyState,
+  ErrorState,
+  LoadingState,
+  ActionButton,
+  setHapticsProvider,
+  getHaptics,
+  setPluginNativeProvider,
+  getPluginNative,
+  gatePluginNative,
+  setCameraPreviewProvider,
+  getCameraPreviewProvider,
+  registerNativePlugin,
+  unregisterNativePlugin,
+  nativePluginRegistry,
+  registerBundleModules,
+  CameraPreview,
+  setPluginThemeColors,
+  usePluginTheme,
+  useApi,
+  PluginSDK,
+  setDeviceStateProvider,
+  gateDeviceState,
+  implementedStateDomains,
+  setVoiceProvider,
+  implementedVoice,
+  gateVoice,
+  resolvePluginGrants,
+  resolvePluginRuntimeProps,
+  useNativeBridge,
+  createNativeBridge,
+  setDeviceToolContextProvider,
+  registerDeviceTools,
+  unregisterDeviceTools,
+  hasDeviceTool,
+  listDeviceTools,
+  callDeviceTool,
+  clearDeviceTools,
+  supportsNative,
+  getNativeComponentId,
+  getNativeBundleUrl,
+  getNativeBundleHash,
+  supportsWebView,
+  listPlugins,
+  getPlugin,
+  resolvePluginUrl,
+  AdaOrb,
+  SurfaceDrawer,
+  SurfaceCard,
+  SurfaceFullscreen,
+  useSurfaceStore,
+  isMountSurface,
+  isInlineSurface,
+  SurfaceDispatcher,
+  MemoryBundleStorage,
+  setBundleStorage,
+  bundleManager,
+  ensureDeviceToolsLoaded,
+  resetDeviceToolLoader
+};
+//# sourceMappingURL=chunk-RXR6M623.mjs.map