@ateam-ai-mobile/plugin-runtime 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2369 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/sdk/index.ts
+var sdk_exports = {};
+__export(sdk_exports, {
+  ActionButton: () => ActionButton,
+  ActivityIndicator: () => ActivityIndicator,
+  Animated: () => Animated,
+  Badge: () => Badge,
+  Card: () => Card,
+  EmptyState: () => EmptyState,
+  ErrorState: () => ErrorState,
+  FlatList: () => FlatList,
+  Image: () => Image,
+  ListItem: () => ListItem,
+  LoadingState: () => LoadingState,
+  Modal: () => Modal,
+  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,
+  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
+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/sdk/usePluginTheme.ts
+import { useMemo, useSyncExternalStore } from "react";
+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 = 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 = useSyncExternalStore(subscribe, () => _colors);
+  const isDark = useSyncExternalStore(subscribe, () => _isDark);
+  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 };
+
+// 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
+import React2 from "react";
+import {
+  useState,
+  useEffect,
+  useCallback,
+  useMemo as useMemo3,
+  useRef,
+  useContext,
+  useReducer,
+  useLayoutEffect,
+  useImperativeHandle,
+  useDebugValue
+} from "react";
+import * as ReactNative from "react-native";
+import { apiFetchRaw } from "@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: React2,
+  ...React2,
+  // Explicitly include hooks (React 19 may not have them as own enumerable props)
+  useState,
+  useEffect,
+  useCallback,
+  useMemo: useMemo3,
+  useRef,
+  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,
+  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 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
+import { useCallback as useCallback2, useMemo as useMemo4, useRef as useRef2, useEffect as useEffect2 } from "react";
+import {
+  connectorCall,
+  mcpFetch as mcpFetchApi,
+  unwrapMcpResult,
+  postCommandResult,
+  getTenant,
+  getUser,
+  pluginCommandEmitter,
+  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: [] } : void 0
+  };
+}
+function useNativeBridge(pluginId, connectorId, commandBufferRef) {
+  const initCallbackRef = useRef2(null);
+  const commandListenersRef = useRef2(/* @__PURE__ */ new Set());
+  const initializedRef = useRef2(false);
+  const fireInit = useCallback2(() => {
+    if (initializedRef.current || !initCallbackRef.current) return;
+    initCallbackRef.current(buildContext(pluginId, connectorId));
+    initializedRef.current = true;
+  }, [pluginId, connectorId]);
+  const onInit = useCallback2((cb) => {
+    initCallbackRef.current = cb;
+    setTimeout(fireInit, 0);
+  }, [fireInit]);
+  const mcpCall = useCallback2(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 = useCallback2(async (body) => {
+    return mcpFetchApi(body);
+  }, []);
+  const sendCommand = useCallback2((type, payload) => {
+    if (type === "plugin.command.result" && payload?.correlationId) {
+      postCommandResult(payload.correlationId, payload.result, payload.error);
+      return;
+    }
+  }, [pluginId]);
+  const onCommand = useCallback2((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 pluginCommandEmitter.drainPluginCommands(pluginId)) {
+      try {
+        cb(cmd.command, { ...cmd.args, correlationId: cmd.correlationId });
+      } catch {
+      }
+    }
+    return () => {
+      commandListenersRef.current.delete(cb);
+    };
+  }, [pluginId, commandBufferRef]);
+  useEffect2(() => {
+    const unsub = 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]);
+  useEffect2(() => {
+    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 pluginCommandEmitter.drainPluginCommands(pluginId)) {
+        dispatch(cmd);
+      }
+    }, 500);
+    return () => clearTimeout(timer);
+  }, [pluginId, commandBufferRef]);
+  useEffect2(() => {
+    return () => {
+      commandListenersRef.current.clear();
+      initializedRef.current = false;
+    };
+  }, []);
+  const close = useCallback2(() => {
+    pluginCommandEmitter.emit("plugin-close", { pluginId });
+  }, [pluginId]);
+  const sendMessage = useCallback2((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 = useCallback2((text) => {
+    const t = (text || "").trim();
+    if (!t) return;
+    pluginCommandEmitter.emit("prepare-chat-message", { text: t });
+  }, []);
+  return useMemo4(
+    () => ({ 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() {
+      pluginCommandEmitter.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;
+      pluginCommandEmitter.emit("prepare-chat-message", { text: t });
+    }
+  };
+}
+
+// src/hooks/usePlugin.ts
+import { useState as useState2, useEffect as useEffect3 } from "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] = useState2(null);
+  const [loading, setLoading] = useState2(true);
+  const [error, setError] = useState2(null);
+  const [bundleMissing, setBundleMissing] = useState2(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.`);
+  }
+  useEffect3(() => {
+    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
+import { useEffect as useEffect4, useState as useState3, useCallback as useCallback3 } from "react";
+import { apiFetch } from "@ateam-ai-mobile/core";
+function useRemotePlugins(solutionId) {
+  const [plugins, setPlugins] = useState3([]);
+  const [loading, setLoading] = useState3(true);
+  const [refreshing, setRefreshing] = useState3(false);
+  const [error, setError] = useState3(null);
+  const fetchRemotePlugins = useCallback3(async () => {
+    try {
+      setError(null);
+      const targetSolutionId = solutionId || "current";
+      let data;
+      try {
+        data = await 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 = useCallback3(async () => {
+    setRefreshing(true);
+    await fetchRemotePlugins();
+  }, [fetchRemotePlugins]);
+  useEffect4(() => {
+    setLoading(true);
+    fetchRemotePlugins();
+  }, [fetchRemotePlugins]);
+  return {
+    plugins,
+    loading,
+    error,
+    refreshing,
+    refresh
+  };
+}
+
+// src/api/plugins.ts
+import { apiFetch as apiFetch2 } 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 apiFetch2("/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 apiFetch2("/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/surfaces/SurfaceDrawer.tsx
+import { useEffect as useEffect6, useRef as useRef3 } 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 as useEffect5 } 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, 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);
+  useEffect5(() => {
+    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__ */ jsx(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__ */ jsx(Stop, { offset: "0%", stopColor: "#FFE0B0", stopOpacity: "1" }),
+        /* @__PURE__ */ jsx(Stop, { offset: "28%", stopColor: "#FFA85A", stopOpacity: "1" }),
+        /* @__PURE__ */ jsx(Stop, { offset: "65%", stopColor: "#FF7A28", stopOpacity: "1" }),
+        /* @__PURE__ */ jsx(Stop, { offset: "100%", stopColor: "#B8410A", stopOpacity: "1" })
+      ] }),
+      /* @__PURE__ */ jsxs(RadialGradient, { id: "adaInner", cx: "50%", cy: "50%", r: "50%", children: [
+        /* @__PURE__ */ jsx(Stop, { offset: "0%", stopColor: "#FF8A3C", stopOpacity: "0.55" }),
+        /* @__PURE__ */ jsx(Stop, { offset: "100%", stopColor: "#FF7028", stopOpacity: "0" })
+      ] }),
+      /* @__PURE__ */ jsxs(RadialGradient, { id: "adaOuter", cx: "50%", cy: "50%", r: "50%", children: [
+        /* @__PURE__ */ jsx(Stop, { offset: "0%", stopColor: "#FF7A28", stopOpacity: "0.4" }),
+        /* @__PURE__ */ jsx(Stop, { offset: "100%", stopColor: "#FF6018", stopOpacity: "0" })
+      ] }),
+      /* @__PURE__ */ jsxs(RadialGradient, { id: "adaSpark", cx: "50%", cy: "50%", r: "50%", children: [
+        /* @__PURE__ */ jsx(Stop, { offset: "0%", stopColor: "#FFFAEB", stopOpacity: "1" }),
+        /* @__PURE__ */ jsx(Stop, { offset: "60%", stopColor: "#FFD095", stopOpacity: "0.9" }),
+        /* @__PURE__ */ jsx(Stop, { offset: "100%", stopColor: "#FFA85A", stopOpacity: "0" })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(
+      AnimatedCircle,
+      {
+        cx: center,
+        cy: center,
+        stroke: "#FF7A28",
+        strokeWidth: 1.5,
+        fill: "none",
+        animatedProps: ripple1Props
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      AnimatedCircle,
+      {
+        cx: center,
+        cy: center,
+        stroke: "#FF7A28",
+        strokeWidth: 1.5,
+        fill: "none",
+        animatedProps: ripple2Props
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      AnimatedCircle,
+      {
+        cx: center,
+        cy: center,
+        stroke: "#FF7A28",
+        strokeWidth: 1.5,
+        fill: "none",
+        animatedProps: ripple3Props
+      }
+    ),
+    /* @__PURE__ */ jsx(AnimatedCircle, { cx: center, cy: center, fill: "url(#adaOuter)", animatedProps: outerProps }),
+    /* @__PURE__ */ jsx(AnimatedCircle, { cx: center, cy: center, fill: "url(#adaInner)", animatedProps: innerProps }),
+    /* @__PURE__ */ jsx(AnimatedCircle, { cx: center, cy: center, fill: "url(#adaCore)", animatedProps: coreProps }),
+    /* @__PURE__ */ jsx(
+      AnimatedCircle,
+      {
+        r: Math.max(3, size * 0.05),
+        fill: "url(#adaSpark)",
+        animatedProps: spark1Props
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      AnimatedCircle,
+      {
+        r: Math.max(2.5, size * 0.04),
+        fill: "url(#adaSpark)",
+        animatedProps: spark2Props
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      AnimatedCircle,
+      {
+        r: Math.max(2, size * 0.032),
+        fill: "url(#adaSpark)",
+        animatedProps: spark3Props
+      }
+    ),
+    showInscription && /* @__PURE__ */ jsx(
+      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 jsx2, 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 = useRef3(new Animated3.Value(0)).current;
+  const slideAnim = useRef3(new Animated3.Value(sheetH)).current;
+  useEffect6(() => {
+    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__ */ jsx2(Pressable3, { style: StyleSheet4.absoluteFill, onPress: close }),
+    /* @__PURE__ */ jsxs2(
+      Animated3.View,
+      {
+        style: [
+          styles3.sheet,
+          { height: sheetH, transform: [{ translateY: slideAnim }] }
+        ],
+        children: [
+          /* @__PURE__ */ jsx2(View4, { style: styles3.handle }),
+          /* @__PURE__ */ jsxs2(View4, { style: styles3.header, children: [
+            showOrb ? /* @__PURE__ */ jsx2(View4, { style: styles3.headerOrb, children: /* @__PURE__ */ jsx2(AdaOrb, { size: 36, state: "idle" }) }) : null,
+            /* @__PURE__ */ jsxs2(View4, { style: { flex: 1 }, children: [
+              /* @__PURE__ */ jsx2(Text3, { style: styles3.title, children: title }),
+              subtitle ? /* @__PURE__ */ jsx2(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__ */ jsx2(Path, { d: "M19 11H5a2 2 0 00-2 2v7a2 2 0 002 2h14a2 2 0 002-2v-7a2 2 0 00-2-2z" }),
+                  /* @__PURE__ */ jsx2(Path, { d: "M7 11V7a5 5 0 0110 0v4" })
+                ] }),
+                /* @__PURE__ */ jsx2(Text3, { style: styles3.privacyText, children: "Only you can see this" })
+              ] }) : null
+            ] }),
+            /* @__PURE__ */ jsx2(
+              Pressable3,
+              {
+                accessibilityRole: "button",
+                accessibilityLabel: "Close",
+                style: styles3.closeBtn,
+                onPress: close,
+                hitSlop: 12,
+                children: /* @__PURE__ */ jsx2(Svg2, { width: 18, height: 18, viewBox: "0 0 24 24", fill: "none", stroke: ada2.inkSoft, strokeWidth: 2.2, strokeLinecap: "round", children: /* @__PURE__ */ jsx2(Path, { d: "M18 6L6 18M6 6l12 12" }) })
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx2(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 jsx3, 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__ */ jsx3(Text4, { style: styles4.icon, children: icon }) : null,
+          /* @__PURE__ */ jsxs3(View5, { style: { flex: 1 }, children: [
+            /* @__PURE__ */ jsx3(Text4, { style: styles4.title, children: title }),
+            subtitle ? /* @__PURE__ */ jsx3(Text4, { style: styles4.subtitle, children: subtitle }) : null
+          ] }),
+          arrow ? /* @__PURE__ */ jsx3(Text4, { style: styles4.arrow, children: "\u2192" }) : null
+        ] }),
+        children ? /* @__PURE__ */ jsx3(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 useEffect7, useRef as useRef4 } 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 jsx4, 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 = useRef4(new Animated4.Value(0)).current;
+  const heroScale = useRef4(new Animated4.Value(0.6)).current;
+  useEffect7(() => {
+    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__ */ jsx4(Svg3, { width: 22, height: 22, viewBox: "0 0 24 24", fill: ada4.paper, children: /* @__PURE__ */ jsx4(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__ */ jsx4(Svg3, { width: 20, height: 20, viewBox: "0 0 24 24", fill: "none", stroke: ada4.paper, strokeWidth: 2.5, strokeLinecap: "round", children: /* @__PURE__ */ jsx4(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__ */ jsx4(Text5, { style: styles5.wordmark, children: "ada" }) : null,
+      status ? /* @__PURE__ */ jsx4(Text5, { style: styles5.status, children: status }) : null
+    ] }),
+    hero ? /* @__PURE__ */ jsx4(View6, { style: styles5.heroWrap, children: /* @__PURE__ */ jsx4(Animated4.View, { style: { transform: [{ scale: heroScale }] }, children: hero }) }) : null,
+    /* @__PURE__ */ jsx4(View6, { style: styles5.body, children }),
+    /* @__PURE__ */ jsxs4(View6, { style: styles5.bottomBar, children: [
+      /* @__PURE__ */ jsx4(
+        Pressable5,
+        {
+          accessibilityRole: "button",
+          accessibilityLabel: closeLabel,
+          style: styles5.closeBtn,
+          onPress: close,
+          hitSlop: 12,
+          children: renderCloseIcon()
+        }
+      ),
+      closeLabel ? /* @__PURE__ */ jsx4(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 useEffect8 } from "react";
+import { pluginCommandEmitter as pluginCommandEmitter2 } from "@ateam-ai-mobile/core";
+import { Fragment, jsx as jsx5, 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);
+  useEffect8(() => {
+    const unsub = pluginCommandEmitter2.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__ */ jsx5(
+      drawer.Component,
+      {
+        dismiss: () => hide(drawer.id),
+        props: drawerProps
+      },
+      `drawer-${drawer.id}-${mountKey}`
+    ) : null,
+    fullscreen && fullscreen.type === "fullscreen" && fullscreen.Component ? /* @__PURE__ */ jsx5(
+      fullscreen.Component,
+      {
+        dismiss: () => hide(fullscreen.id),
+        props: fullscreenProps
+      },
+      `fullscreen-${fullscreen.id}-${mountKey}`
+    ) : null
+  ] });
+}
+export {
+  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.mjs.map