@ateam-ai-mobile/plugin-runtime 0.1.0

package/dist/index.js

@@ -0,0 +1,2388 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ActionButton: () => ActionButton,
+  ActivityIndicator: () => import_react_native.ActivityIndicator,
+  AdaOrb: () => AdaOrb,
+  Animated: () => import_react_native.Animated,
+  Badge: () => Badge,
+  Card: () => Card,
+  EmptyState: () => EmptyState,
+  ErrorState: () => ErrorState,
+  FlatList: () => import_react_native.FlatList,
+  Image: () => import_react_native.Image,
+  ListItem: () => ListItem,
+  LoadingState: () => LoadingState,
+  MemoryBundleStorage: () => MemoryBundleStorage,
+  Modal: () => import_react_native.Modal,
+  Platform: () => import_react_native.Platform,
+  PluginSDK: () => PluginSDK,
+  Pressable: () => import_react_native.Pressable,
+  RefreshControl: () => import_react_native.RefreshControl,
+  ScrollView: () => import_react_native.ScrollView,
+  SearchBar: () => SearchBar,
+  SectionList: () => import_react_native.SectionList,
+  StyleSheet: () => import_react_native.StyleSheet,
+  SurfaceCard: () => SurfaceCard,
+  SurfaceDispatcher: () => SurfaceDispatcher,
+  SurfaceDrawer: () => SurfaceDrawer,
+  SurfaceFullscreen: () => SurfaceFullscreen,
+  Switch: () => import_react_native.Switch,
+  TabBar: () => TabBar,
+  Text: () => import_react_native.Text,
+  TextInput: () => import_react_native.TextInput,
+  TouchableOpacity: () => import_react_native.TouchableOpacity,
+  View: () => import_react_native.View,
+  bundleManager: () => bundleManager,
+  createNativeBridge: () => createNativeBridge,
+  getHaptics: () => getHaptics,
+  getNativeBundleHash: () => getNativeBundleHash,
+  getNativeBundleUrl: () => getNativeBundleUrl,
+  getNativeComponentId: () => getNativeComponentId,
+  getPlugin: () => getPlugin,
+  getPluginNative: () => getPluginNative,
+  isInlineSurface: () => isInlineSurface,
+  isMountSurface: () => isMountSurface,
+  listPlugins: () => listPlugins,
+  nativePluginRegistry: () => nativePluginRegistry,
+  register: () => register,
+  registerBundleModules: () => registerBundleModules,
+  registerNativePlugin: () => registerNativePlugin,
+  registerService: () => registerService,
+  resolvePluginUrl: () => resolvePluginUrl,
+  setBundleStorage: () => setBundleStorage,
+  setHapticsProvider: () => setHapticsProvider,
+  setPluginNativeProvider: () => setPluginNativeProvider,
+  setPluginThemeColors: () => setPluginThemeColors,
+  supportsNative: () => supportsNative,
+  supportsWebView: () => supportsWebView,
+  unregisterNativePlugin: () => unregisterNativePlugin,
+  useApi: () => useApi,
+  useNativeBridge: () => useNativeBridge,
+  usePlugin: () => usePlugin,
+  usePluginTheme: () => usePluginTheme,
+  useRemotePlugins: () => useRemotePlugins,
+  useSurfaceStore: () => useSurfaceStore
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/sdk/index.ts
+var sdk_exports = {};
+__export(sdk_exports, {
+  ActionButton: () => ActionButton,
+  ActivityIndicator: () => import_react_native.ActivityIndicator,
+  Animated: () => import_react_native.Animated,
+  Badge: () => Badge,
+  Card: () => Card,
+  EmptyState: () => EmptyState,
+  ErrorState: () => ErrorState,
+  FlatList: () => import_react_native.FlatList,
+  Image: () => import_react_native.Image,
+  ListItem: () => ListItem,
+  LoadingState: () => LoadingState,
+  Modal: () => import_react_native.Modal,
+  Platform: () => import_react_native.Platform,
+  PluginSDK: () => PluginSDK,
+  Pressable: () => import_react_native.Pressable,
+  RefreshControl: () => import_react_native.RefreshControl,
+  ScrollView: () => import_react_native.ScrollView,
+  SearchBar: () => SearchBar,
+  SectionList: () => import_react_native.SectionList,
+  StyleSheet: () => import_react_native.StyleSheet,
+  Switch: () => import_react_native.Switch,
+  TabBar: () => TabBar,
+  Text: () => import_react_native.Text,
+  TextInput: () => import_react_native.TextInput,
+  TouchableOpacity: () => import_react_native.TouchableOpacity,
+  View: () => import_react_native.View,
+  register: () => register,
+  registerService: () => registerService,
+  setPluginThemeColors: () => setPluginThemeColors,
+  useApi: () => useApi,
+  usePluginTheme: () => usePluginTheme
+});
+
+// src/sdk/registration.ts
+function register(id, config) {
+  return {
+    id,
+    type: config.type || "ui",
+    capabilities: config.capabilities,
+    Component: config.Component
+  };
+}
+function registerService(id, config) {
+  return {
+    id,
+    type: "service",
+    capabilities: config.capabilities,
+    hooks: config.hooks,
+    onStart: config.onStart,
+    onStop: config.onStop
+  };
+}
+
+// src/sdk/primitives.ts
+var import_react_native = require("react-native");
+
+// src/sdk/components.ts
+var import_react = __toESM(require("react"));
+var import_react_native2 = require("react-native");
+function Card({ theme, children, style, onPress }) {
+  const cardStyle = [
+    styles.card,
+    {
+      backgroundColor: theme.colors.surface,
+      borderColor: theme.colors.border
+    },
+    style
+  ];
+  if (onPress) {
+    return import_react.default.createElement(import_react_native2.Pressable, { style: cardStyle, onPress }, children);
+  }
+  return import_react.default.createElement(import_react_native2.View, { style: cardStyle }, children);
+}
+var BADGE_COLORS = {
+  accent: { bg: "accentSoft", text: "accent" },
+  success: { bg: "successSoft", text: "success" },
+  warning: { bg: "warningSoft", text: "warning" },
+  error: { bg: "errorSoft", text: "error" },
+  purple: { bg: "purpleSoft", text: "purple" }
+};
+function Badge({ theme, label, color = "accent", style }) {
+  const mapping = BADGE_COLORS[color];
+  return import_react.default.createElement(
+    import_react_native2.View,
+    {
+      style: [
+        styles.badge,
+        {
+          backgroundColor: theme.colors[mapping.bg],
+          borderRadius: theme.borderRadius.sm
+        },
+        style
+      ]
+    },
+    import_react.default.createElement(import_react_native2.Text, {
+      style: [styles.badgeText, { color: theme.colors[mapping.text] }]
+    }, label)
+  );
+}
+function TabBar({ theme, tabs, activeTab, onTabChange, style }) {
+  return import_react.default.createElement(
+    import_react_native2.View,
+    {
+      style: [
+        styles.tabBar,
+        { borderBottomColor: theme.colors.border },
+        style
+      ]
+    },
+    tabs.map(
+      (tab) => import_react.default.createElement(
+        import_react_native2.Pressable,
+        {
+          key: tab,
+          style: [
+            styles.tab,
+            {
+              borderBottomColor: tab === activeTab ? theme.colors.accent : "transparent"
+            }
+          ],
+          onPress: () => onTabChange(tab)
+        },
+        import_react.default.createElement(import_react_native2.Text, {
+          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 = [
+    import_react.default.createElement(
+      import_react_native2.View,
+      { key: "content", style: styles.listItemContent },
+      import_react.default.createElement(import_react_native2.Text, {
+        style: { color: theme.colors.text, fontSize: theme.fontSize.md },
+        numberOfLines: 1
+      }, title),
+      subtitle ? import_react.default.createElement(import_react_native2.Text, {
+        style: { color: theme.colors.textSecondary, fontSize: theme.fontSize.xs, marginTop: 2 },
+        numberOfLines: 1
+      }, subtitle) : null
+    ),
+    right ? import_react.default.createElement(import_react_native2.View, { key: "right" }, right) : null
+  ];
+  if (onPress) {
+    return import_react.default.createElement(
+      import_react_native2.Pressable,
+      { style: [styles.listItem, { borderBottomColor: theme.colors.border }, style], onPress },
+      ...content
+    );
+  }
+  return import_react.default.createElement(
+    import_react_native2.View,
+    { style: [styles.listItem, { borderBottomColor: theme.colors.border }, style] },
+    ...content
+  );
+}
+function SearchBar({ theme, value, onChangeText, placeholder = "Search...", style }) {
+  return import_react.default.createElement(import_react_native2.TextInput, {
+    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 import_react.default.createElement(
+    import_react_native2.View,
+    { style: [styles.emptyState, style] },
+    import_react.default.createElement(import_react_native2.Text, {
+      style: { color: theme.colors.textSecondary, fontSize: theme.fontSize.md, textAlign: "center" }
+    }, title),
+    subtitle ? import_react.default.createElement(import_react_native2.Text, {
+      style: { color: theme.colors.textMuted, fontSize: theme.fontSize.sm, textAlign: "center", marginTop: 4 }
+    }, subtitle) : null
+  );
+}
+function ErrorState({ theme, message, onRetry, style }) {
+  return import_react.default.createElement(
+    import_react_native2.View,
+    { style: [styles.emptyState, style] },
+    import_react.default.createElement(import_react_native2.Text, {
+      style: { color: theme.colors.error, fontSize: theme.fontSize.md, textAlign: "center" }
+    }, message),
+    onRetry ? import_react.default.createElement(
+      import_react_native2.Pressable,
+      {
+        style: [styles.retryButton, { backgroundColor: theme.colors.accentSoft, borderRadius: theme.borderRadius.sm }],
+        onPress: onRetry
+      },
+      import_react.default.createElement(import_react_native2.Text, {
+        style: { color: theme.colors.accent, fontSize: theme.fontSize.sm, fontWeight: "600" }
+      }, "Retry")
+    ) : null
+  );
+}
+function LoadingState({ theme, message = "Loading...", style }) {
+  return import_react.default.createElement(
+    import_react_native2.View,
+    { style: [styles.emptyState, style] },
+    import_react.default.createElement(import_react_native2.ActivityIndicator, { size: "small", color: theme.colors.accent }),
+    import_react.default.createElement(import_react_native2.Text, {
+      style: { color: theme.colors.textSecondary, fontSize: theme.fontSize.sm, marginTop: 8 }
+    }, message)
+  );
+}
+function ActionButton({ theme, label, icon, onPress, style }) {
+  return import_react.default.createElement(
+    import_react_native2.Pressable,
+    {
+      style: [
+        styles.fab,
+        { backgroundColor: theme.colors.accent, borderRadius: theme.borderRadius.full },
+        style
+      ],
+      onPress
+    },
+    icon || import_react.default.createElement(import_react_native2.Text, { style: styles.fabText }, label || "+")
+  );
+}
+var styles = import_react_native2.StyleSheet.create({
+  card: {
+    padding: 12,
+    borderRadius: 12,
+    borderWidth: 1,
+    marginBottom: 8
+  },
+  badge: {
+    paddingHorizontal: 8,
+    paddingVertical: 3
+  },
+  badgeText: {
+    fontSize: 11,
+    fontWeight: "600"
+  },
+  tabBar: {
+    flexDirection: "row",
+    borderBottomWidth: 1
+  },
+  tab: {
+    flex: 1,
+    padding: 12,
+    alignItems: "center",
+    borderBottomWidth: 2
+  },
+  listItem: {
+    flexDirection: "row",
+    alignItems: "center",
+    paddingVertical: 12,
+    paddingHorizontal: 16,
+    borderBottomWidth: import_react_native2.StyleSheet.hairlineWidth
+  },
+  listItemContent: {
+    flex: 1
+  },
+  searchBar: {
+    height: 40,
+    paddingHorizontal: 12,
+    borderWidth: 1
+  },
+  emptyState: {
+    flex: 1,
+    justifyContent: "center",
+    alignItems: "center",
+    padding: 32
+  },
+  retryButton: {
+    marginTop: 12,
+    paddingHorizontal: 16,
+    paddingVertical: 8
+  },
+  fab: {
+    position: "absolute",
+    bottom: 24,
+    right: 24,
+    width: 56,
+    height: 56,
+    justifyContent: "center",
+    alignItems: "center",
+    shadowColor: "#000",
+    shadowOffset: { width: 0, height: 2 },
+    shadowOpacity: 0.25,
+    shadowRadius: 4,
+    elevation: 5
+  },
+  fabText: {
+    color: "#fff",
+    fontSize: 24,
+    fontWeight: "600"
+  }
+});
+
+// src/sdk/usePluginTheme.ts
+var import_react2 = require("react");
+var import_core = require("@ateam-ai-mobile/core");
+var adaColors = {
+  bg: import_core.ada.paper,
+  surface: import_core.ada.paperSoft,
+  surfaceAlt: import_core.ada.paperDeep,
+  input: import_core.ada.paper,
+  border: import_core.ada.border,
+  text: import_core.ada.ink,
+  textSecondary: import_core.ada.inkSoft,
+  textMuted: import_core.ada.inkMuted,
+  accent: import_core.ada.orange,
+  accentSoft: import_core.ada.orangeSoft,
+  success: "#5A8A5C",
+  successSoft: "rgba(90,138,92,0.14)",
+  warning: "#D49A4E",
+  warningSoft: "rgba(212,154,78,0.16)",
+  error: "#C15545",
+  errorSoft: "rgba(193,85,69,0.14)",
+  purple: import_core.ada.orangeDeep,
+  purpleSoft: import_core.ada.orangeSoft
+};
+var _colors = adaColors;
+var _isDark = false;
+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 = (0, import_react2.useSyncExternalStore)(subscribe, () => _colors);
+  const isDark = (0, import_react2.useSyncExternalStore)(subscribe, () => _isDark);
+  return (0, import_react2.useMemo)(() => ({
+    colors,
+    spacing: {
+      xs: import_core.spacing.xs,
+      sm: import_core.spacing.sm,
+      md: import_core.spacing.md,
+      lg: import_core.spacing.lg,
+      xl: import_core.spacing.xl,
+      xxl: import_core.spacing.xxl
+    },
+    fontSize: {
+      xs: import_core.fontSize.xs,
+      sm: import_core.fontSize.sm,
+      md: import_core.fontSize.md,
+      lg: import_core.fontSize.lg,
+      xl: import_core.fontSize.xl
+    },
+    borderRadius: {
+      sm: import_core.borderRadius.sm,
+      md: import_core.borderRadius.md,
+      lg: import_core.borderRadius.lg,
+      full: import_core.borderRadius.full
+    },
+    isDark
+  }), [colors, isDark]);
+}
+
+// src/sdk/useApi.ts
+var import_react3 = require("react");
+function useApi(bridge) {
+  return (0, import_react3.useMemo)(() => {
+    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 };
+
+// src/host.ts
+var _haptics = null;
+function setHapticsProvider(haptics) {
+  _haptics = haptics;
+}
+function getHaptics() {
+  return _haptics;
+}
+function unavailable(api) {
+  return new Proxy({}, {
+    get: (_t, method) => () => Promise.reject(new Error(`[adas] native.${api}.${String(method)} unavailable \u2014 host did not call setPluginNativeProvider()`))
+  });
+}
+var noopNative = {
+  camera: unavailable("camera"),
+  location: unavailable("location"),
+  storage: unavailable("storage"),
+  biometrics: unavailable("biometrics"),
+  biometricsV2: unavailable("biometricsV2"),
+  notifications: unavailable("notifications"),
+  haptics: { impact: () => {
+  }, notification: () => {
+  }, selection: () => {
+  } },
+  connectivity: { isOnline: () => true, onChange: () => () => {
+  } },
+  fileSystem: unavailable("fileSystem"),
+  cookies: unavailable("cookies"),
+  sharing: unavailable("sharing"),
+  scanner: unavailable("scanner"),
+  nfc: unavailable("nfc")
+};
+var _pluginNative = noopNative;
+function setPluginNativeProvider(native) {
+  _pluginNative = native;
+}
+function getPluginNative() {
+  return _pluginNative;
+}
+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/bundles/bundleManager.ts
+var import_react4 = __toESM(require("react"));
+var import_react5 = require("react");
+var ReactNative = __toESM(require("react-native"));
+var import_core2 = require("@ateam-ai-mobile/core");
+
+// 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/storage.ts
+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/bundles/bundleManager.ts
+var ReactShim = {
+  __esModule: true,
+  default: import_react4.default,
+  ...import_react4.default,
+  // Explicitly include hooks (React 19 may not have them as own enumerable props)
+  useState: import_react5.useState,
+  useEffect: import_react5.useEffect,
+  useCallback: import_react5.useCallback,
+  useMemo: import_react5.useMemo,
+  useRef: import_react5.useRef,
+  useContext: import_react5.useContext,
+  useReducer: import_react5.useReducer,
+  useLayoutEffect: import_react5.useLayoutEffect,
+  useImperativeHandle: import_react5.useImperativeHandle,
+  useDebugValue: import_react5.useDebugValue,
+  createElement: import_react4.default.createElement,
+  Fragment: import_react4.default.Fragment,
+  Component: import_react4.default.Component,
+  PureComponent: import_react4.default.PureComponent,
+  createContext: import_react4.default.createContext,
+  forwardRef: import_react4.default.forwardRef,
+  memo: import_react4.default.memo,
+  Children: import_react4.default.Children,
+  cloneElement: import_react4.default.cloneElement,
+  isValidElement: import_react4.default.isValidElement,
+  createRef: import_react4.default.createRef,
+  lazy: import_react4.default.lazy,
+  Suspense: import_react4.default.Suspense
+};
+var PluginSDKShim = Object.freeze({
+  ...sdk_exports,
+  PluginSDK: Object.freeze({
+    ...PluginSDK,
+    register: PluginSDK.register
+  }),
+  register
+});
+var requireShim = (name) => {
+  if (name === "react") return ReactShim;
+  if (name === "react-native") return ReactNative;
+  if (name === "@adas/plugin-sdk") return PluginSDKShim;
+  const hostModule = resolveBundleModule(name);
+  if (hostModule !== void 0) return hostModule;
+  console.warn(`[BundleManager] Unknown module: ${name} \u2014 register it via registerBundleModules()`);
+  return {};
+};
+var CACHE_TTL = 7 * 24 * 60 * 60 * 1e3;
+var BundleManager = class {
+  constructor() {
+    /** In-memory module cache: bundleUrl → evaluated module.exports */
+    this.modules = /* @__PURE__ */ new Map();
+    /** In-flight download deduplication: bundleUrl → Promise */
+    this.inflight = /* @__PURE__ */ new Map();
+  }
+  // ── Public API ──────────────────────────────────────────────
+  /**
+   * Load a plugin component. Returns the RegisteredUIPlugin object.
+   * Handles: in-memory cache → disk cache → download → evaluate → extract.
+   *
+   * `expectedHash` (SHA-256 hex from cp.getContextPlugin manifest) MUST be
+   * provided for any bundle the user has not previously verified — without
+   * it, a tampered bundle is `eval`'d as JS with full RN runtime + every
+   * native capability the manifest declares.
+   */
+  async load(pluginId, bundleUrl, version, expectedHash) {
+    const cached = this.getComponentFromMemory(pluginId, bundleUrl);
+    if (cached) return cached;
+    let modulePromise = this.inflight.get(bundleUrl);
+    if (!modulePromise) {
+      modulePromise = this.loadModule(bundleUrl, version, expectedHash);
+      this.inflight.set(bundleUrl, modulePromise);
+      modulePromise.catch(() => {
+      }).finally(() => this.inflight.delete(bundleUrl));
+    }
+    await modulePromise;
+    const component = this.getComponentFromMemory(pluginId, bundleUrl);
+    if (!component) {
+      throw new Error(
+        `Bundle loaded from ${bundleUrl} but no component found for "${pluginId}". Available exports: ${this.describeModule(this.modules.get(bundleUrl))}`
+      );
+    }
+    return component;
+  }
+  /**
+   * Prewarm: load every plugin bundle in the background after app boot, so a
+   * later open is instant (in-memory hit) instead of round-tripping the
+   * network. Errors are swallowed per-plugin — one bad bundle shouldn't
+   * block others. Concurrency capped at 3.
+   */
+  async prewarmAll(items) {
+    const queue = [...items];
+    const concurrency = Math.min(3, queue.length);
+    const start = Date.now();
+    let okCount = 0;
+    let failCount = 0;
+    const worker = async () => {
+      while (queue.length > 0) {
+        const it = queue.shift();
+        if (!it) return;
+        try {
+          await this.load(it.pluginId, it.bundleUrl, it.version, it.bundleHash);
+          okCount++;
+        } catch (err) {
+          failCount++;
+          console.log(`[prewarm] ${it.pluginId}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    };
+    await Promise.all(Array.from({ length: concurrency }, worker));
+    console.log(`[prewarm] ${okCount} loaded, ${failCount} failed in ${Date.now() - start}ms`);
+  }
+  /**
+   * Clear all caches (in-memory + storage).
+   */
+  async clearAll() {
+    this.modules.clear();
+    try {
+      await getBundleStorage().clearAll();
+    } catch (err) {
+      console.warn("[BundleManager] clearAll error:", err);
+    }
+  }
+  /**
+   * Clear cache for a specific plugin/bundle.
+   */
+  async clearPlugin(pluginId) {
+    const storage = getBundleStorage();
+    const index = await storage.loadIndex();
+    const entry = index[pluginId];
+    if (entry) {
+      this.modules.delete(entry.bundleUrl);
+      delete index[pluginId];
+      await storage.saveIndex(index);
+      try {
+        await storage.deleteBundle(entry.localPath);
+      } catch {
+      }
+    }
+  }
+  // ── Private: module loading pipeline ────────────────────────
+  async loadModule(bundleUrl, version, expectedHash) {
+    if (this.modules.has(bundleUrl)) return;
+    const storage = getBundleStorage();
+    const index = await storage.loadIndex();
+    const expectedLc = expectedHash ? expectedHash.toLowerCase() : null;
+    let content = null;
+    for (const entry of Object.values(index)) {
+      if (entry.bundleUrl === bundleUrl && entry.version === version) {
+        const age = Date.now() - entry.timestamp;
+        const hashOk = expectedLc && entry.bundleHash && entry.bundleHash.toLowerCase() === expectedLc;
+        if (age < CACHE_TTL && hashOk) {
+          content = await storage.readBundle(entry.localPath);
+          if (content) break;
+        }
+      }
+    }
+    if (!content) {
+      const downloaded = await this.download(bundleUrl, expectedLc);
+      content = downloaded.content;
+      const safeName = bundleUrl.replace(/[^a-zA-Z0-9]/g, "_").slice(-80);
+      try {
+        const localPath = await storage.writeBundle(`${safeName}@${version}.js`, content);
+        index[bundleUrl] = {
+          localPath,
+          version,
+          timestamp: Date.now(),
+          bundleUrl,
+          bundleHash: downloaded.sha256
+        };
+        await storage.saveIndex(index);
+      } catch (err) {
+        console.warn("[BundleManager] Cache write error:", err);
+      }
+    }
+    const mod = this.evaluate(content, bundleUrl);
+    this.modules.set(bundleUrl, mod);
+  }
+  /**
+   * Download + integrity-verify a bundle. Refuses to return when:
+   *   - manifest hash and computed hash disagree
+   *   - server's `X-Bundle-SHA256` disagrees with manifest hash
+   *   - no expected hash AND no server hash header (cannot prove the bundle
+   *     wasn't tampered with — fail closed rather than trust the wire).
+   */
+  async download(bundleUrl, expectedHash) {
+    const cacheBust = `${bundleUrl}${bundleUrl.includes("?") ? "&" : "?"}t=${Date.now()}`;
+    const response = await (0, import_core2.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) {
+    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.
+   * Handles: default export, direct key match, multi-plugin .id match.
+   */
+  getComponentFromMemory(pluginId, bundleUrl) {
+    const mod = this.modules.get(bundleUrl);
+    if (!mod) return null;
+    const shortName = pluginId.includes(":") ? pluginId.split(":").pop() : pluginId;
+    if (mod[pluginId] && typeof mod[pluginId].Component === "function") {
+      return mod[pluginId];
+    }
+    const pascal = shortName.replace(/(^|-)([a-z])/g, (_, __, c) => c.toUpperCase());
+    if (mod[pascal] && typeof mod[pascal] === "object" && typeof mod[pascal].Component === "function") {
+      return mod[pascal];
+    }
+    if (mod.default && typeof mod.default === "object" && typeof mod.default.Component === "function") {
+      return mod.default;
+    }
+    for (const key of Object.keys(mod)) {
+      const val = mod[key];
+      if (val && typeof val === "object" && val.id === shortName && typeof val.Component === "function") {
+        return val;
+      }
+    }
+    return null;
+  }
+  describeModule(mod) {
+    if (!mod) return "(empty)";
+    return Object.keys(mod).map((k) => {
+      const v = mod[k];
+      if (v && typeof v === "object" && v.id) return `${k}(id="${v.id}")`;
+      return k;
+    }).join(", ");
+  }
+};
+var bundleManager = new BundleManager();
+
+// src/bridge/native.ts
+var import_react6 = require("react");
+var import_core3 = require("@ateam-ai-mobile/core");
+function buildContext(pluginId, connectorId) {
+  const user = (0, import_core3.getUser)();
+  return {
+    tenant: (0, import_core3.getTenant)(),
+    pluginId,
+    connectorId,
+    user: user ? { id: user.actorId || "", name: user.name || "", roles: [] } : void 0
+  };
+}
+function useNativeBridge(pluginId, connectorId, commandBufferRef) {
+  const initCallbackRef = (0, import_react6.useRef)(null);
+  const commandListenersRef = (0, import_react6.useRef)(/* @__PURE__ */ new Set());
+  const initializedRef = (0, import_react6.useRef)(false);
+  const fireInit = (0, import_react6.useCallback)(() => {
+    if (initializedRef.current || !initCallbackRef.current) return;
+    initCallbackRef.current(buildContext(pluginId, connectorId));
+    initializedRef.current = true;
+  }, [pluginId, connectorId]);
+  const onInit = (0, import_react6.useCallback)((cb) => {
+    initCallbackRef.current = cb;
+    setTimeout(fireInit, 0);
+  }, [fireInit]);
+  const mcpCall = (0, import_react6.useCallback)(async (toolOrConnector, argsOrTool, cIdOrArgs) => {
+    let tool;
+    let args;
+    let cId;
+    if (typeof argsOrTool === "string") {
+      cId = toolOrConnector;
+      tool = argsOrTool;
+      args = cIdOrArgs || {};
+    } else {
+      tool = toolOrConnector;
+      args = argsOrTool;
+      cId = typeof cIdOrArgs === "string" ? cIdOrArgs : void 0;
+    }
+    const targetConnector = cId || connectorId;
+    if (!targetConnector) {
+      console.warn(`[NativeBridge:${pluginId}] mcpCall failed \u2014 no connectorId. tool=${tool}`);
+      throw new Error(`[NativeBridge:${pluginId}] mcpCall requires a connectorId`);
+    }
+    try {
+      const data = await (0, import_core3.connectorCall)(targetConnector, tool, args);
+      if (!data.ok && data.error) {
+        throw new Error(data.error);
+      }
+      return (0, import_core3.unwrapMcpResult)(data.result);
+    } catch (err) {
+      console.warn(`[NativeBridge:${pluginId}] mcpCall failed \u2192 connector=${targetConnector} tool=${tool}:`, err?.message || err);
+      throw err;
+    }
+  }, [pluginId, connectorId]);
+  const mcpFetch = (0, import_react6.useCallback)(async (body) => {
+    return (0, import_core3.mcpFetch)(body);
+  }, []);
+  const sendCommand = (0, import_react6.useCallback)((type, payload) => {
+    if (type === "plugin.command.result" && payload?.correlationId) {
+      (0, import_core3.postCommandResult)(payload.correlationId, payload.result, payload.error);
+      return;
+    }
+  }, [pluginId]);
+  const onCommand = (0, import_react6.useCallback)((cb) => {
+    commandListenersRef.current.add(cb);
+    if (commandBufferRef) {
+      const buf = commandBufferRef.current;
+      const remaining = [];
+      for (const cmd of buf) {
+        if (cmd.pluginId === pluginId && cmd.command !== "__focus") {
+          try {
+            cb(cmd.command, { ...cmd.args, correlationId: cmd.correlationId });
+          } catch {
+          }
+        } else {
+          remaining.push(cmd);
+        }
+      }
+      commandBufferRef.current = remaining;
+    }
+    for (const cmd of import_core3.pluginCommandEmitter.drainPluginCommands(pluginId)) {
+      try {
+        cb(cmd.command, { ...cmd.args, correlationId: cmd.correlationId });
+      } catch {
+      }
+    }
+    return () => {
+      commandListenersRef.current.delete(cb);
+    };
+  }, [pluginId, commandBufferRef]);
+  (0, import_react6.useEffect)(() => {
+    const unsub = import_core3.pluginCommandEmitter.on("plugin-command", (cmd) => {
+      if (cmd.pluginId !== pluginId) return;
+      if (cmd.command === "__focus") return;
+      commandListenersRef.current.forEach((fn) => {
+        try {
+          fn(cmd.command, { ...cmd.args, correlationId: cmd.correlationId });
+        } catch {
+        }
+      });
+    });
+    return unsub;
+  }, [pluginId]);
+  (0, import_react6.useEffect)(() => {
+    const timer = setTimeout(() => {
+      const dispatch = (cmd) => {
+        commandListenersRef.current.forEach((fn) => {
+          try {
+            fn(cmd.command, { ...cmd.args, correlationId: cmd.correlationId });
+          } catch {
+          }
+        });
+      };
+      if (commandBufferRef) {
+        const remaining = [];
+        for (const cmd of commandBufferRef.current) {
+          if (cmd.pluginId === pluginId && cmd.command !== "__focus") dispatch(cmd);
+          else remaining.push(cmd);
+        }
+        commandBufferRef.current = remaining;
+      }
+      for (const cmd of import_core3.pluginCommandEmitter.drainPluginCommands(pluginId)) {
+        dispatch(cmd);
+      }
+    }, 500);
+    return () => clearTimeout(timer);
+  }, [pluginId, commandBufferRef]);
+  (0, import_react6.useEffect)(() => {
+    return () => {
+      commandListenersRef.current.clear();
+      initializedRef.current = false;
+    };
+  }, []);
+  const close = (0, import_react6.useCallback)(() => {
+    import_core3.pluginCommandEmitter.emit("plugin-close", { pluginId });
+  }, [pluginId]);
+  const sendMessage = (0, import_react6.useCallback)((text) => {
+    const t = (text || "").trim();
+    if (!t) return;
+    try {
+      import_core3.useChatStore.getState().sendMessage(t);
+    } catch (err) {
+      console.warn("[bridge.sendMessage] failed:", err instanceof Error ? err.message : String(err));
+    }
+  }, []);
+  const prepareMessage = (0, import_react6.useCallback)((text) => {
+    const t = (text || "").trim();
+    if (!t) return;
+    import_core3.pluginCommandEmitter.emit("prepare-chat-message", { text: t });
+  }, []);
+  return (0, import_react6.useMemo)(
+    () => ({ onInit, mcpCall, mcpFetch, sendCommand, onCommand, close, sendMessage, prepareMessage }),
+    [onInit, mcpCall, mcpFetch, sendCommand, onCommand, close, sendMessage, prepareMessage]
+  );
+}
+function createNativeBridge(pluginId, connectorId) {
+  const commandListeners = /* @__PURE__ */ new Set();
+  return {
+    onInit(cb) {
+      setTimeout(() => {
+        cb(buildContext(pluginId, connectorId));
+      }, 0);
+    },
+    async mcpCall(tool, args, cId) {
+      const targetConnector = cId || connectorId;
+      if (!targetConnector) {
+        throw new Error(`[NativeBridge:${pluginId}] mcpCall requires a connectorId`);
+      }
+      const data = await (0, import_core3.connectorCall)(targetConnector, tool, args);
+      if (!data.ok && data.error) throw new Error(data.error);
+      return (0, import_core3.unwrapMcpResult)(data.result);
+    },
+    async mcpFetch(body) {
+      return (0, import_core3.mcpFetch)(body);
+    },
+    sendCommand(_type, _payload) {
+    },
+    onCommand(cb) {
+      commandListeners.add(cb);
+      return () => {
+        commandListeners.delete(cb);
+      };
+    },
+    close() {
+      import_core3.pluginCommandEmitter.emit("plugin-close", { pluginId });
+    },
+    sendMessage(text) {
+      const t = (text || "").trim();
+      if (!t) return;
+      try {
+        import_core3.useChatStore.getState().sendMessage(t);
+      } catch (err) {
+        console.warn("[bridge.sendMessage] failed:", err instanceof Error ? err.message : String(err));
+      }
+    },
+    prepareMessage(text) {
+      const t = (text || "").trim();
+      if (!t) return;
+      import_core3.pluginCommandEmitter.emit("prepare-chat-message", { text: t });
+    }
+  };
+}
+
+// src/hooks/usePlugin.ts
+var import_react7 = require("react");
+function extractBundleUrl(pluginId, manifest) {
+  const render = manifest.render;
+  if (!render || typeof render !== "object") return { url: null, source: "none" };
+  const injected = manifest.bundleUrl || render.bundleUrl || render.reactNative?.bundleUrl || null;
+  const hasNativeComponent = !!(render.reactNative?.component || render.component);
+  if (hasNativeComponent) {
+    return {
+      url: `/api/ui-plugins/${encodeURIComponent(pluginId)}/bundle.js`,
+      source: injected ? "ignored-explicit" : "derived-default",
+      ...injected && { ignored: injected }
+    };
+  }
+  return { url: null, source: "none" };
+}
+function extractBundleHash(manifest) {
+  if (manifest.bundleHash) return manifest.bundleHash;
+  const render = manifest.render;
+  if (!render || typeof render !== "object") return void 0;
+  if (render.bundleHash) return render.bundleHash;
+  if (render.reactNative?.bundleHash) return render.reactNative.bundleHash;
+  return void 0;
+}
+function extractComponentId(manifest) {
+  const render = manifest.render;
+  if (!render || typeof render !== "object") return null;
+  return render.component || render.reactNative?.component || null;
+}
+function usePlugin(pluginId, manifest) {
+  const [plugin, setPlugin] = (0, import_react7.useState)(null);
+  const [loading, setLoading] = (0, import_react7.useState)(true);
+  const [error, setError] = (0, import_react7.useState)(null);
+  const [bundleMissing, setBundleMissing] = (0, import_react7.useState)(false);
+  const version = manifest.version || "1.0.0";
+  const { url: bundleUrl, ignored: ignoredUrl } = extractBundleUrl(pluginId, manifest);
+  const bundleHash = extractBundleHash(manifest);
+  const componentId = extractComponentId(manifest);
+  const lookupId = componentId || pluginId;
+  if (ignoredUrl) {
+    console.warn(`[usePlugin] ${pluginId}: IGNORED connector-injected bundleUrl="${ignoredUrl}". The host derives bundle URLs from pluginId via the canonical route.`);
+  }
+  (0, import_react7.useEffect)(() => {
+    let cancelled = false;
+    (async () => {
+      try {
+        if (nativePluginRegistry.has(lookupId)) {
+          const registered = await nativePluginRegistry.get(lookupId);
+          if (cancelled) return;
+          if (!registered) {
+            throw new Error(`Local plugin not found: ${lookupId}`);
+          }
+          if (registered.type === "service") {
+            throw new Error(`Plugin ${lookupId} is a service plugin and cannot be rendered`);
+          }
+          setPlugin(registered);
+          setLoading(false);
+          return;
+        }
+        if (bundleUrl) {
+          try {
+            const component = await bundleManager.load(pluginId, bundleUrl, version, bundleHash);
+            if (cancelled) return;
+            setPlugin(component);
+            setLoading(false);
+            return;
+          } catch (bundleErr) {
+            const msg = bundleErr instanceof Error ? bundleErr.message : String(bundleErr);
+            console.warn(`[usePlugin] ${pluginId}: Bundle load failed, falling back to WebView:`, msg);
+            if (!cancelled) {
+              setBundleMissing(true);
+              setLoading(false);
+            }
+            return;
+          }
+        }
+        const iframeUrl = manifest?.render?.iframeUrl || manifest?.render?.mode === "adaptive" && manifest?.render?.iframe?.iframeUrl;
+        if (iframeUrl) {
+          if (!cancelled) {
+            setBundleMissing(true);
+            setLoading(false);
+          }
+          return;
+        }
+        throw new Error(
+          `Plugin "${manifest.name || pluginId}" has no bundle URL and is not in the local registry. Check that the solution definition includes a valid render.reactNative.bundleUrl.`
+        );
+      } catch (err) {
+        if (cancelled) return;
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error(`[usePlugin] Failed to load ${pluginId}:`, msg);
+        setError(msg);
+        setLoading(false);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [pluginId, lookupId, bundleUrl, bundleHash, version]);
+  return { plugin, loading, error, bundleMissing };
+}
+
+// src/hooks/useRemotePlugins.ts
+var import_react8 = require("react");
+var import_core4 = require("@ateam-ai-mobile/core");
+function useRemotePlugins(solutionId) {
+  const [plugins, setPlugins] = (0, import_react8.useState)([]);
+  const [loading, setLoading] = (0, import_react8.useState)(true);
+  const [refreshing, setRefreshing] = (0, import_react8.useState)(false);
+  const [error, setError] = (0, import_react8.useState)(null);
+  const fetchRemotePlugins = (0, import_react8.useCallback)(async () => {
+    try {
+      setError(null);
+      const targetSolutionId = solutionId || "current";
+      let data;
+      try {
+        data = await (0, import_core4.apiFetch)(`/api/solutions/${targetSolutionId}/ui-plugins`);
+      } catch (err) {
+        if (err?.message?.includes("404")) {
+          console.warn(`[useRemotePlugins] Solution ${targetSolutionId} not found or has no plugins`);
+          setPlugins([]);
+          return;
+        }
+        throw err;
+      }
+      const uiPlugins = (data.plugins || []).map((plugin) => ({
+        id: plugin.id,
+        name: plugin.name,
+        version: plugin.version || "1.0.0",
+        source: "remote",
+        manifest: {
+          id: plugin.id,
+          name: plugin.name,
+          version: plugin.version || "1.0.0",
+          type: "ui",
+          description: plugin.description || "",
+          capabilities: plugin.capabilities || {},
+          channels: plugin.channels || ["default"],
+          render: plugin.render && typeof plugin.render === "object" ? plugin.render : { mode: "react-native", component: plugin.name || plugin.id },
+          entry_point: plugin.entry_point || plugin.name,
+          sandbox: plugin.sandbox !== false,
+          requires_auth: plugin.requires_auth !== false
+        }
+      }));
+      setPlugins(uiPlugins);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error("[useRemotePlugins] Failed to fetch plugins:", message);
+      setError(message);
+      setPlugins([]);
+    } finally {
+      setLoading(false);
+      setRefreshing(false);
+    }
+  }, [solutionId]);
+  const refresh = (0, import_react8.useCallback)(async () => {
+    setRefreshing(true);
+    await fetchRemotePlugins();
+  }, [fetchRemotePlugins]);
+  (0, import_react8.useEffect)(() => {
+    setLoading(true);
+    fetchRemotePlugins();
+  }, [fetchRemotePlugins]);
+  return {
+    plugins,
+    loading,
+    error,
+    refreshing,
+    refresh
+  };
+}
+
+// src/api/plugins.ts
+var import_core5 = require("@ateam-ai-mobile/core");
+var import_core6 = require("@ateam-ai-mobile/core");
+function supportsNative(manifest) {
+  const mode = manifest.render?.mode;
+  return mode === "react-native" || mode === "adaptive";
+}
+function getNativeComponentId(manifest) {
+  if (manifest.render?.mode === "react-native") return manifest.render.component;
+  if (manifest.render?.mode === "adaptive") return manifest.render.reactNative?.component;
+  return null;
+}
+function getNativeBundleUrl(manifest) {
+  const direct = manifest.bundleUrl;
+  if (direct) return direct;
+  const render = manifest.render;
+  if (render.mode === "react-native") return render.bundleUrl || null;
+  if (render.mode === "adaptive") return render.reactNative?.bundleUrl || null;
+  return null;
+}
+function getNativeBundleHash(manifest) {
+  const direct = manifest.bundleHash;
+  if (direct) return direct;
+  const render = manifest.render;
+  if (render.mode === "react-native") return render.bundleHash || null;
+  if (render.mode === "adaptive") return render.reactNative?.bundleHash || null;
+  return null;
+}
+function supportsWebView(manifest) {
+  return manifest.render?.mode === "iframe" || manifest.render?.mode === "adaptive";
+}
+async function listPlugins() {
+  const res = await (0, import_core5.apiFetch)("/mcp", {
+    method: "POST",
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: Date.now(),
+      method: "tools/call",
+      params: {
+        name: "cp.listContextPlugins",
+        arguments: {}
+      }
+    })
+  });
+  const structured = res.result?.structuredContent?.plugins;
+  if (structured) return structured;
+  const text = res.result?.content?.[0]?.text;
+  if (!text) return [];
+  try {
+    const parsed = JSON.parse(text);
+    return parsed.plugins || parsed || [];
+  } catch {
+    return [];
+  }
+}
+async function getPlugin(pluginId) {
+  const res = await (0, import_core5.apiFetch)("/mcp", {
+    method: "POST",
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: Date.now(),
+      method: "tools/call",
+      params: {
+        name: "cp.getContextPlugin",
+        arguments: { id: pluginId }
+        // Backend expects { id }, NOT { pluginId }
+      }
+    })
+  });
+  if (res.result?.structuredContent) return res.result.structuredContent;
+  const text = res.result?.content?.[0]?.text;
+  if (!text) return null;
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed.error) {
+      console.warn("[getPlugin] Backend error:", parsed.error);
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function resolvePluginUrl(manifest, tenant) {
+  const render = manifest.render;
+  let url;
+  if (render?.mode === "iframe") {
+    url = render.iframeUrl;
+  } else if (render?.mode === "adaptive") {
+    url = render.iframeUrl || render.iframe?.iframeUrl;
+  }
+  if (!url) return "";
+  if (url.startsWith("http")) {
+    const sep = url.includes("?") ? "&" : "?";
+    return tenant ? `${url}${sep}tenant=${encodeURIComponent(tenant)}` : url;
+  }
+  if (tenant && url.startsWith("/mcp-ui/")) {
+    const tenantUrl = url.replace("/mcp-ui/", `/mcp-ui/${encodeURIComponent(tenant)}/`);
+    return `${(0, import_core6.getCoreApiUrl)()}${tenantUrl}`;
+  }
+  return `${(0, import_core6.getCoreApiUrl)()}${url}`;
+}
+
+// src/surfaces/SurfaceDrawer.tsx
+var import_react10 = require("react");
+var import_react_native4 = require("react-native");
+var import_react_native_svg2 = __toESM(require("react-native-svg"));
+var import_core7 = require("@ateam-ai-mobile/core");
+
+// src/surfaces/AdaOrb.tsx
+var import_react9 = require("react");
+var import_react_native3 = require("react-native");
+var import_react_native_reanimated = __toESM(require("react-native-reanimated"));
+var import_react_native_svg = __toESM(require("react-native-svg"));
+var import_jsx_runtime = require("react/jsx-runtime");
+var AnimatedCircle = import_react_native_reanimated.default.createAnimatedComponent(import_react_native_svg.Circle);
+function AdaOrb({ size = 120, state = "idle", inscription = true }) {
+  const showInscription = inscription && size >= 60;
+  const center = size / 2;
+  const coreR = size * 0.32;
+  const innerHaloR = size * 0.42;
+  const outerHaloR = size * 0.5;
+  const coreScale = (0, import_react_native_reanimated.useSharedValue)(1);
+  const innerScale = (0, import_react_native_reanimated.useSharedValue)(1);
+  const outerScale = (0, import_react_native_reanimated.useSharedValue)(1);
+  const outerOpacity = (0, import_react_native_reanimated.useSharedValue)(0.55);
+  const rippleCycle = (0, import_react_native_reanimated.useSharedValue)(0);
+  const orbit1 = (0, import_react_native_reanimated.useSharedValue)(0);
+  const orbit2 = (0, import_react_native_reanimated.useSharedValue)(0);
+  const orbit3 = (0, import_react_native_reanimated.useSharedValue)(0);
+  const beat = (0, import_react_native_reanimated.useSharedValue)(1);
+  (0, import_react9.useEffect)(() => {
+    (0, import_react_native_reanimated.cancelAnimation)(coreScale);
+    (0, import_react_native_reanimated.cancelAnimation)(innerScale);
+    (0, import_react_native_reanimated.cancelAnimation)(outerScale);
+    (0, import_react_native_reanimated.cancelAnimation)(outerOpacity);
+    (0, import_react_native_reanimated.cancelAnimation)(rippleCycle);
+    (0, import_react_native_reanimated.cancelAnimation)(orbit1);
+    (0, import_react_native_reanimated.cancelAnimation)(orbit2);
+    (0, import_react_native_reanimated.cancelAnimation)(orbit3);
+    (0, import_react_native_reanimated.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 = (0, import_react_native_reanimated.withRepeat)(
+        (0, import_react_native_reanimated.withTiming)(1, { duration: 2e3, easing: import_react_native_reanimated.Easing.out(import_react_native_reanimated.Easing.quad) }),
+        -1,
+        false
+      );
+    } else if (state === "thinking") {
+      breathMs = 2400;
+      breathAmount = 0.04;
+      orbit1.value = (0, import_react_native_reanimated.withRepeat)(
+        (0, import_react_native_reanimated.withTiming)(1, { duration: 1100, easing: import_react_native_reanimated.Easing.linear }),
+        -1,
+        false
+      );
+      orbit2.value = (0, import_react_native_reanimated.withRepeat)(
+        (0, import_react_native_reanimated.withTiming)(1, { duration: 1900, easing: import_react_native_reanimated.Easing.linear }),
+        -1,
+        false
+      );
+      orbit3.value = (0, import_react_native_reanimated.withRepeat)(
+        (0, import_react_native_reanimated.withTiming)(-1, { duration: 2700, easing: import_react_native_reanimated.Easing.linear }),
+        -1,
+        false
+      );
+    } else if (state === "speaking") {
+      breathMs = 700;
+      breathAmount = 0.13;
+      beat.value = (0, import_react_native_reanimated.withRepeat)(
+        (0, import_react_native_reanimated.withSequence)(
+          (0, import_react_native_reanimated.withTiming)(1.08, { duration: 90, easing: import_react_native_reanimated.Easing.out(import_react_native_reanimated.Easing.quad) }),
+          (0, import_react_native_reanimated.withTiming)(1, { duration: 130, easing: import_react_native_reanimated.Easing.in(import_react_native_reanimated.Easing.quad) }),
+          (0, import_react_native_reanimated.withTiming)(1.05, { duration: 80, easing: import_react_native_reanimated.Easing.out(import_react_native_reanimated.Easing.quad) }),
+          (0, import_react_native_reanimated.withTiming)(1, { duration: 200, easing: import_react_native_reanimated.Easing.in(import_react_native_reanimated.Easing.quad) }),
+          (0, import_react_native_reanimated.withTiming)(1, { duration: 280 })
+        ),
+        -1,
+        false
+      );
+    }
+    const breathEasing = state === "speaking" ? import_react_native_reanimated.Easing.out(import_react_native_reanimated.Easing.cubic) : import_react_native_reanimated.Easing.inOut(import_react_native_reanimated.Easing.sin);
+    coreScale.value = (0, import_react_native_reanimated.withRepeat)(
+      (0, import_react_native_reanimated.withSequence)(
+        (0, import_react_native_reanimated.withTiming)(1 + breathAmount, { duration: breathMs, easing: breathEasing }),
+        (0, import_react_native_reanimated.withTiming)(1, { duration: breathMs, easing: breathEasing })
+      ),
+      -1,
+      false
+    );
+    innerScale.value = (0, import_react_native_reanimated.withRepeat)(
+      (0, import_react_native_reanimated.withSequence)(
+        (0, import_react_native_reanimated.withTiming)(1 + breathAmount * 1.4, { duration: breathMs * 1.15, easing: breathEasing }),
+        (0, import_react_native_reanimated.withTiming)(1, { duration: breathMs * 1.15, easing: breathEasing })
+      ),
+      -1,
+      false
+    );
+    outerScale.value = (0, import_react_native_reanimated.withRepeat)(
+      (0, import_react_native_reanimated.withSequence)(
+        (0, import_react_native_reanimated.withTiming)(1 + breathAmount * 1.8, { duration: breathMs * 1.3, easing: breathEasing }),
+        (0, import_react_native_reanimated.withTiming)(1, { duration: breathMs * 1.3, easing: breathEasing })
+      ),
+      -1,
+      false
+    );
+    outerOpacity.value = (0, import_react_native_reanimated.withRepeat)(
+      (0, import_react_native_reanimated.withSequence)(
+        (0, import_react_native_reanimated.withTiming)(state === "idle" ? 0.55 : 0.8, { duration: breathMs * 1.3, easing: breathEasing }),
+        (0, import_react_native_reanimated.withTiming)(0.35, { duration: breathMs * 1.3, easing: breathEasing })
+      ),
+      -1,
+      false
+    );
+  }, [state]);
+  const coreProps = (0, import_react_native_reanimated.useAnimatedProps)(() => ({
+    r: coreR * coreScale.value * beat.value
+  }));
+  const innerProps = (0, import_react_native_reanimated.useAnimatedProps)(() => ({
+    r: innerHaloR * innerScale.value * beat.value
+  }));
+  const outerProps = (0, import_react_native_reanimated.useAnimatedProps)(() => ({
+    r: outerHaloR * outerScale.value,
+    opacity: outerOpacity.value
+  }));
+  const ripple1Props = (0, import_react_native_reanimated.useAnimatedProps)(() => {
+    const t = rippleCycle.value;
+    return {
+      r: outerHaloR * (1 + t * 0.55),
+      opacity: state === "listening" ? 0.55 * (1 - t) : 0
+    };
+  });
+  const ripple2Props = (0, import_react_native_reanimated.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 = (0, import_react_native_reanimated.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 = (0, import_react_native_reanimated.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 = (0, import_react_native_reanimated.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 = (0, import_react_native_reanimated.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__ */ (0, import_jsx_runtime.jsx)(import_react_native3.View, { style: [styles2.wrap, { width: size, height: size }], children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react_native_svg.default, { width: size, height: size, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react_native_svg.Defs, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react_native_svg.RadialGradient, { id: "adaCore", cx: "36%", cy: "30%", r: "70%", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native_svg.Stop, { offset: "0%", stopColor: "#FFE0B0", stopOpacity: "1" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native_svg.Stop, { offset: "28%", stopColor: "#FFA85A", stopOpacity: "1" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native_svg.Stop, { offset: "65%", stopColor: "#FF7A28", stopOpacity: "1" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native_svg.Stop, { offset: "100%", stopColor: "#B8410A", stopOpacity: "1" })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react_native_svg.RadialGradient, { id: "adaInner", cx: "50%", cy: "50%", r: "50%", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native_svg.Stop, { offset: "0%", stopColor: "#FF8A3C", stopOpacity: "0.55" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native_svg.Stop, { offset: "100%", stopColor: "#FF7028", stopOpacity: "0" })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react_native_svg.RadialGradient, { id: "adaOuter", cx: "50%", cy: "50%", r: "50%", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native_svg.Stop, { offset: "0%", stopColor: "#FF7A28", stopOpacity: "0.4" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native_svg.Stop, { offset: "100%", stopColor: "#FF6018", stopOpacity: "0" })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_react_native_svg.RadialGradient, { id: "adaSpark", cx: "50%", cy: "50%", r: "50%", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native_svg.Stop, { offset: "0%", stopColor: "#FFFAEB", stopOpacity: "1" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native_svg.Stop, { offset: "60%", stopColor: "#FFD095", stopOpacity: "0.9" }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_native_svg.Stop, { offset: "100%", stopColor: "#FFA85A", stopOpacity: "0" })
+      ] })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      AnimatedCircle,
+      {
+        cx: center,
+        cy: center,
+        stroke: "#FF7A28",
+        strokeWidth: 1.5,
+        fill: "none",
+        animatedProps: ripple1Props
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      AnimatedCircle,
+      {
+        cx: center,
+        cy: center,
+        stroke: "#FF7A28",
+        strokeWidth: 1.5,
+        fill: "none",
+        animatedProps: ripple2Props
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      AnimatedCircle,
+      {
+        cx: center,
+        cy: center,
+        stroke: "#FF7A28",
+        strokeWidth: 1.5,
+        fill: "none",
+        animatedProps: ripple3Props
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AnimatedCircle, { cx: center, cy: center, fill: "url(#adaOuter)", animatedProps: outerProps }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AnimatedCircle, { cx: center, cy: center, fill: "url(#adaInner)", animatedProps: innerProps }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AnimatedCircle, { cx: center, cy: center, fill: "url(#adaCore)", animatedProps: coreProps }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      AnimatedCircle,
+      {
+        r: Math.max(3, size * 0.05),
+        fill: "url(#adaSpark)",
+        animatedProps: spark1Props
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      AnimatedCircle,
+      {
+        r: Math.max(2.5, size * 0.04),
+        fill: "url(#adaSpark)",
+        animatedProps: spark2Props
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      AnimatedCircle,
+      {
+        r: Math.max(2, size * 0.032),
+        fill: "url(#adaSpark)",
+        animatedProps: spark3Props
+      }
+    ),
+    showInscription && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_react_native_svg.Text,
+      {
+        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 = import_react_native3.StyleSheet.create({
+  wrap: {
+    alignItems: "center",
+    justifyContent: "center"
+  }
+});
+
+// src/surfaces/SurfaceDrawer.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var SCREEN_H = import_react_native4.Dimensions.get("window").height;
+var fontFam = import_react_native4.Platform.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 = (0, import_react10.useRef)(new import_react_native4.Animated.Value(0)).current;
+  const slideAnim = (0, import_react10.useRef)(new import_react_native4.Animated.Value(sheetH)).current;
+  (0, import_react10.useEffect)(() => {
+    if (visible) {
+      import_react_native4.Animated.parallel([
+        import_react_native4.Animated.timing(fadeAnim, { toValue: 1, duration: 220, useNativeDriver: true }),
+        import_react_native4.Animated.spring(slideAnim, { toValue: 0, useNativeDriver: true, tension: 80, friction: 12 })
+      ]).start();
+    } else {
+      fadeAnim.setValue(0);
+      slideAnim.setValue(sheetH);
+    }
+  }, [visible]);
+  const close = () => {
+    import_react_native4.Animated.parallel([
+      import_react_native4.Animated.timing(fadeAnim, { toValue: 0, duration: 160, useNativeDriver: true }),
+      import_react_native4.Animated.timing(slideAnim, { toValue: sheetH, duration: 200, useNativeDriver: true })
+    ]).start(() => onClose());
+  };
+  if (!visible) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_native4.Animated.View, { style: [styles3.overlay, { opacity: fadeAnim }], pointerEvents: "auto", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native4.Pressable, { style: import_react_native4.StyleSheet.absoluteFill, onPress: close }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+      import_react_native4.Animated.View,
+      {
+        style: [
+          styles3.sheet,
+          { height: sheetH, transform: [{ translateY: slideAnim }] }
+        ],
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native4.View, { style: styles3.handle }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_native4.View, { style: styles3.header, children: [
+            showOrb ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native4.View, { style: styles3.headerOrb, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(AdaOrb, { size: 36, state: "idle" }) }) : null,
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_native4.View, { style: { flex: 1 }, children: [
+              /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native4.Text, { style: styles3.title, children: title }),
+              subtitle ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native4.Text, { style: styles3.subtitle, children: subtitle }) : null,
+              privacy ? /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_native4.View, { style: styles3.privacyPill, children: [
+                /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_native_svg2.default, { width: 11, height: 11, viewBox: "0 0 24 24", fill: "none", stroke: import_core7.ada.inkSoft, strokeWidth: 2.5, strokeLinecap: "round", strokeLinejoin: "round", children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native_svg2.Path, { d: "M19 11H5a2 2 0 00-2 2v7a2 2 0 002 2h14a2 2 0 002-2v-7a2 2 0 00-2-2z" }),
+                  /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native_svg2.Path, { d: "M7 11V7a5 5 0 0110 0v4" })
+                ] }),
+                /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native4.Text, { style: styles3.privacyText, children: "Only you can see this" })
+              ] }) : null
+            ] }),
+            /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+              import_react_native4.Pressable,
+              {
+                accessibilityRole: "button",
+                accessibilityLabel: "Close",
+                style: styles3.closeBtn,
+                onPress: close,
+                hitSlop: 12,
+                children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native_svg2.default, { width: 18, height: 18, viewBox: "0 0 24 24", fill: "none", stroke: import_core7.ada.inkSoft, strokeWidth: 2.2, strokeLinecap: "round", children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native_svg2.Path, { d: "M18 6L6 18M6 6l12 12" }) })
+              }
+            )
+          ] }),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_react_native4.View, { style: styles3.body, children })
+        ]
+      }
+    )
+  ] });
+}
+var styles3 = import_react_native4.StyleSheet.create({
+  overlay: {
+    position: "absolute",
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0,
+    backgroundColor: "rgba(26, 20, 16, 0.35)",
+    justifyContent: "flex-end",
+    zIndex: 999,
+    elevation: 999
+  },
+  sheet: {
+    backgroundColor: import_core7.ada.paper,
+    borderTopLeftRadius: 28,
+    borderTopRightRadius: 28,
+    overflow: "hidden"
+  },
+  handle: {
+    width: 40,
+    height: 4,
+    borderRadius: 2,
+    backgroundColor: import_core7.ada.inkMuted,
+    opacity: 0.3,
+    alignSelf: "center",
+    marginTop: 10,
+    marginBottom: 6
+  },
+  header: {
+    flexDirection: "row",
+    alignItems: "center",
+    paddingHorizontal: 22,
+    paddingVertical: 16,
+    gap: 12,
+    borderBottomWidth: 1,
+    borderBottomColor: import_core7.ada.border
+  },
+  headerOrb: {
+    width: 36,
+    height: 36,
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  title: {
+    fontSize: 17,
+    fontWeight: "600",
+    color: import_core7.ada.ink,
+    letterSpacing: -0.2,
+    fontFamily: fontFam
+  },
+  subtitle: {
+    fontSize: 13,
+    fontWeight: "400",
+    color: import_core7.ada.inkSoft,
+    marginTop: 2,
+    letterSpacing: -0.1,
+    fontFamily: fontFam
+  },
+  privacyPill: {
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 5,
+    marginTop: 4
+  },
+  privacyText: {
+    fontSize: 11,
+    fontWeight: "500",
+    color: import_core7.ada.inkSoft,
+    letterSpacing: 0.2,
+    fontFamily: fontFam
+  },
+  closeBtn: {
+    width: 32,
+    height: 32,
+    borderRadius: 16,
+    backgroundColor: import_core7.ada.paperSoft,
+    justifyContent: "center",
+    alignItems: "center"
+  },
+  body: {
+    flex: 1
+  }
+});
+
+// src/surfaces/SurfaceCard.tsx
+var import_react_native5 = require("react-native");
+var import_core8 = require("@ateam-ai-mobile/core");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var fontFam2 = import_react_native5.Platform.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__ */ (0, import_jsx_runtime3.jsxs)(
+    import_react_native5.Pressable,
+    {
+      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__ */ (0, import_jsx_runtime3.jsxs)(import_react_native5.View, { style: styles4.row, children: [
+          icon ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native5.Text, { style: styles4.icon, children: icon }) : null,
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_react_native5.View, { style: { flex: 1 }, children: [
+            /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native5.Text, { style: styles4.title, children: title }),
+            subtitle ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native5.Text, { style: styles4.subtitle, children: subtitle }) : null
+          ] }),
+          arrow ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native5.Text, { style: styles4.arrow, children: "\u2192" }) : null
+        ] }),
+        children ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_native5.View, { style: styles4.body, children }) : null
+      ]
+    }
+  );
+}
+var styles4 = import_react_native5.StyleSheet.create({
+  card: {
+    backgroundColor: import_core8.ada.paperSoft,
+    borderWidth: 1,
+    borderColor: import_core8.ada.border,
+    borderRadius: import_core8.borderRadius.xl,
+    paddingHorizontal: 16,
+    paddingVertical: 14
+  },
+  row: {
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 14
+  },
+  icon: {
+    fontSize: 22
+  },
+  title: {
+    fontSize: 15,
+    fontWeight: "600",
+    color: import_core8.ada.ink,
+    letterSpacing: -0.2,
+    fontFamily: fontFam2
+  },
+  subtitle: {
+    fontSize: 13,
+    fontWeight: "400",
+    color: import_core8.ada.inkMuted,
+    marginTop: 2,
+    letterSpacing: -0.1,
+    fontFamily: fontFam2
+  },
+  arrow: {
+    fontSize: 18,
+    color: import_core8.ada.inkMuted,
+    fontWeight: "400"
+  },
+  body: {
+    marginTop: 10,
+    paddingTop: 10,
+    borderTopWidth: 1,
+    borderTopColor: import_core8.ada.border
+  }
+});
+
+// src/surfaces/SurfaceFullscreen.tsx
+var import_react11 = require("react");
+var import_react_native6 = require("react-native");
+var import_react_native_svg3 = __toESM(require("react-native-svg"));
+var import_core9 = require("@ateam-ai-mobile/core");
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var fontFam3 = import_react_native6.Platform.OS === "ios" ? "SF Pro Rounded" : void 0;
+function SurfaceFullscreen({
+  visible,
+  onClose,
+  status,
+  hero,
+  children,
+  showWordmark = true,
+  closeIcon = "x",
+  closeLabel = "Close"
+}) {
+  const fadeAnim = (0, import_react11.useRef)(new import_react_native6.Animated.Value(0)).current;
+  const heroScale = (0, import_react11.useRef)(new import_react_native6.Animated.Value(0.6)).current;
+  (0, import_react11.useEffect)(() => {
+    if (visible) {
+      import_react_native6.Animated.parallel([
+        import_react_native6.Animated.timing(fadeAnim, { toValue: 1, duration: 280, useNativeDriver: true }),
+        import_react_native6.Animated.spring(heroScale, { toValue: 1, useNativeDriver: true, tension: 60, friction: 11 })
+      ]).start();
+    } else {
+      fadeAnim.setValue(0);
+      heroScale.setValue(0.6);
+    }
+  }, [visible]);
+  const close = () => {
+    import_react_native6.Animated.parallel([
+      import_react_native6.Animated.timing(fadeAnim, { toValue: 0, duration: 180, useNativeDriver: true }),
+      import_react_native6.Animated.timing(heroScale, { toValue: 0.6, duration: 180, useNativeDriver: true })
+    ]).start(() => onClose());
+  };
+  if (!visible) return null;
+  const renderCloseIcon = () => {
+    if (closeIcon === "hangup") {
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native_svg3.default, { width: 22, height: 22, viewBox: "0 0 24 24", fill: import_core9.ada.paper, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native_svg3.Path, { d: "M3.68 16.07l3.92-3.11c.28-.23.68-.28 1.01-.14l2.77 1.15c.36.15.61.5.61.89v2.82c4.34-.76 7.93-4.35 8.69-8.69h-2.82c-.39 0-.74-.25-.89-.61L16.12 5.6c-.13-.33-.09-.73.14-1.01l3.11-3.92c.29-.37.81-.41 1.15-.08l3.24 3.24c.2.2.31.47.31.76C24 14.44 14.44 24 4.59 24c-.29 0-.56-.11-.76-.31L.59 20.45c-.33-.34-.29-.86.09-1.15z" }) });
+    }
+    if (closeIcon === "x") {
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native_svg3.default, { width: 20, height: 20, viewBox: "0 0 24 24", fill: "none", stroke: import_core9.ada.paper, strokeWidth: 2.5, strokeLinecap: "round", children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native_svg3.Path, { d: "M18 6L6 18M6 6l12 12" }) });
+    }
+    return closeIcon;
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_react_native6.Animated.View, { style: [styles5.overlay, { opacity: fadeAnim }], pointerEvents: "auto", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_react_native6.View, { style: styles5.topBar, children: [
+      showWordmark ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native6.Text, { style: styles5.wordmark, children: "ada" }) : null,
+      status ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native6.Text, { style: styles5.status, children: status }) : null
+    ] }),
+    hero ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native6.View, { style: styles5.heroWrap, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native6.Animated.View, { style: { transform: [{ scale: heroScale }] }, children: hero }) }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native6.View, { style: styles5.body, children }),
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_react_native6.View, { style: styles5.bottomBar, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+        import_react_native6.Pressable,
+        {
+          accessibilityRole: "button",
+          accessibilityLabel: closeLabel,
+          style: styles5.closeBtn,
+          onPress: close,
+          hitSlop: 12,
+          children: renderCloseIcon()
+        }
+      ),
+      closeLabel ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_react_native6.Text, { style: styles5.closeLabel, children: closeLabel }) : null
+    ] })
+  ] });
+}
+var styles5 = import_react_native6.StyleSheet.create({
+  overlay: {
+    position: "absolute",
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0,
+    backgroundColor: import_core9.ada.paper,
+    zIndex: 1e3,
+    elevation: 1e3
+  },
+  topBar: {
+    paddingTop: import_react_native6.Platform.OS === "ios" ? 64 : 36,
+    paddingHorizontal: 24,
+    alignItems: "center",
+    gap: 6
+  },
+  wordmark: {
+    fontSize: 14,
+    fontFamily: fontFam3,
+    fontWeight: "500",
+    color: import_core9.ada.inkMuted,
+    letterSpacing: 4
+  },
+  status: {
+    fontSize: 17,
+    fontFamily: fontFam3,
+    fontWeight: "500",
+    color: import_core9.ada.ink,
+    letterSpacing: -0.2
+  },
+  heroWrap: {
+    paddingTop: 24,
+    paddingBottom: 12,
+    alignItems: "center",
+    justifyContent: "center"
+  },
+  body: {
+    flex: 1
+  },
+  bottomBar: {
+    paddingBottom: import_react_native6.Platform.OS === "ios" ? 48 : 32,
+    paddingTop: 12,
+    alignItems: "center",
+    gap: 8
+  },
+  closeBtn: {
+    width: 64,
+    height: 64,
+    borderRadius: 32,
+    backgroundColor: import_core9.ada.ink,
+    justifyContent: "center",
+    alignItems: "center",
+    shadowColor: import_core9.ada.ink,
+    shadowOffset: { width: 0, height: 8 },
+    shadowOpacity: 0.18,
+    shadowRadius: 14,
+    elevation: 8
+  },
+  closeLabel: {
+    fontSize: 13,
+    fontFamily: fontFam3,
+    fontWeight: "500",
+    color: import_core9.ada.inkMuted,
+    letterSpacing: 0.3
+  }
+});
+
+// src/registry/store.ts
+var import_zustand = require("zustand");
+var useSurfaceStore = (0, import_zustand.create)((set, get) => ({
+  manifests: {},
+  activeDrawer: null,
+  activeFullscreen: null,
+  activeProps: {},
+  mountKey: 0,
+  register: (manifest) => set((s) => ({ manifests: { ...s.manifests, [manifest.id]: manifest } })),
+  unregister: (id) => set((s) => {
+    const next = { ...s.manifests };
+    delete next[id];
+    const nextProps = { ...s.activeProps };
+    delete nextProps[id];
+    return { manifests: next, activeProps: nextProps };
+  }),
+  show: (id, props) => {
+    const m = get().manifests[id];
+    if (!m) {
+      console.warn("[SurfaceStore] show: unknown surface id", id);
+      return;
+    }
+    set((s) => {
+      const nextProps = props !== void 0 ? { ...s.activeProps, [id]: props } : s.activeProps;
+      const mountKey = s.mountKey + 1;
+      if (m.type === "drawer") return { activeDrawer: id, activeProps: nextProps, mountKey };
+      if (m.type === "fullscreen") return { activeFullscreen: id, activeProps: nextProps, mountKey };
+      return { mountKey };
+    });
+  },
+  hide: (id) => {
+    const s = get();
+    if (!id) {
+      const cleanup2 = { ...s.activeProps };
+      if (s.activeDrawer) delete cleanup2[s.activeDrawer];
+      if (s.activeFullscreen) delete cleanup2[s.activeFullscreen];
+      set({ activeDrawer: null, activeFullscreen: null, activeProps: cleanup2 });
+      return;
+    }
+    const cleanup = { ...s.activeProps };
+    delete cleanup[id];
+    const patch = { activeProps: cleanup };
+    if (s.activeDrawer === id) patch.activeDrawer = null;
+    if (s.activeFullscreen === id) patch.activeFullscreen = null;
+    set(patch);
+  },
+  list: (filter) => {
+    const all = Object.values(get().manifests);
+    return all.filter((m) => {
+      if (filter?.type && m.type !== filter.type) return false;
+      if (filter?.visibility && !filter.visibility.includes(m.visibility)) return false;
+      if (filter?.placement) {
+        if (filter.placement === "unset") {
+          if (m.placement) return false;
+        } else if (m.placement !== filter.placement) {
+          return false;
+        }
+      }
+      return true;
+    });
+  }
+}));
+function isMountSurface(m) {
+  return m.type === "drawer" || m.type === "fullscreen";
+}
+function isInlineSurface(m) {
+  return m.type === "card" || m.type === "header" || m.type === "ambient" || m.type === "nudge";
+}
+
+// src/registry/SurfaceDispatcher.tsx
+var import_react12 = require("react");
+var import_core10 = require("@ateam-ai-mobile/core");
+var import_jsx_runtime5 = require("react/jsx-runtime");
+function SurfaceDispatcher() {
+  const manifests = useSurfaceStore((s) => s.manifests);
+  const activeDrawer = useSurfaceStore((s) => s.activeDrawer);
+  const activeFullscreen = useSurfaceStore((s) => s.activeFullscreen);
+  const activeProps = useSurfaceStore((s) => s.activeProps);
+  const mountKey = useSurfaceStore((s) => s.mountKey);
+  const hide = useSurfaceStore((s) => s.hide);
+  (0, import_react12.useEffect)(() => {
+    const unsub = import_core10.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__ */ (0, import_jsx_runtime5.jsxs)(import_jsx_runtime5.Fragment, { children: [
+    drawer && drawer.type === "drawer" && drawer.Component ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      drawer.Component,
+      {
+        dismiss: () => hide(drawer.id),
+        props: drawerProps
+      },
+      `drawer-${drawer.id}-${mountKey}`
+    ) : null,
+    fullscreen && fullscreen.type === "fullscreen" && fullscreen.Component ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+      fullscreen.Component,
+      {
+        dismiss: () => hide(fullscreen.id),
+        props: fullscreenProps
+      },
+      `fullscreen-${fullscreen.id}-${mountKey}`
+    ) : null
+  ] });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActionButton,
+  ActivityIndicator,
+  AdaOrb,
+  Animated,
+  Badge,
+  Card,
+  EmptyState,
+  ErrorState,
+  FlatList,
+  Image,
+  ListItem,
+  LoadingState,
+  MemoryBundleStorage,
+  Modal,
+  Platform,
+  PluginSDK,
+  Pressable,
+  RefreshControl,
+  ScrollView,
+  SearchBar,
+  SectionList,
+  StyleSheet,
+  SurfaceCard,
+  SurfaceDispatcher,
+  SurfaceDrawer,
+  SurfaceFullscreen,
+  Switch,
+  TabBar,
+  Text,
+  TextInput,
+  TouchableOpacity,
+  View,
+  bundleManager,
+  createNativeBridge,
+  getHaptics,
+  getNativeBundleHash,
+  getNativeBundleUrl,
+  getNativeComponentId,
+  getPlugin,
+  getPluginNative,
+  isInlineSurface,
+  isMountSurface,
+  listPlugins,
+  nativePluginRegistry,
+  register,
+  registerBundleModules,
+  registerNativePlugin,
+  registerService,
+  resolvePluginUrl,
+  setBundleStorage,
+  setHapticsProvider,
+  setPluginNativeProvider,
+  setPluginThemeColors,
+  supportsNative,
+  supportsWebView,
+  unregisterNativePlugin,
+  useApi,
+  useNativeBridge,
+  usePlugin,
+  usePluginTheme,
+  useRemotePlugins,
+  useSurfaceStore
+});
+//# sourceMappingURL=index.js.map