@qontinui/ui-bridge-native 0.1.5 → 0.2.0

package/dist/react/index.mjs

@@ -53,9 +53,34 @@ var NativeUIBridgeRegistry = class {
     this.components = /* @__PURE__ */ new Map();
     this.workflows = /* @__PURE__ */ new Map();
     this.eventListeners = /* @__PURE__ */ new Map();
+    this.enrichers = {};
+    this.snapshotExtras = /* @__PURE__ */ new Map();
     this.config = config;
   }
   // ============================================================================
+  // Snapshot Enricher Slots
+  // ============================================================================
+  /**
+   * Register/replace canonical enrichers (modal/toast/undo). HMR-safe — calling
+   * with a partial set merges into existing slots instead of clobbering them.
+   */
+  setEnrichers(e) {
+    this.enrichers = { ...this.enrichers, ...e };
+  }
+  /**
+   * Register a custom snapshot enricher. The returned object will be
+   * `Object.assign`ed onto the snapshot, so use unique top-level keys to avoid
+   * clobbering canonical fields. Returns a disposer.
+   */
+  registerSnapshotEnricher(name, fn) {
+    this.snapshotExtras.set(name, fn);
+    return () => this.unregisterSnapshotEnricher(name);
+  }
+  /** Remove a custom snapshot enricher by name */
+  unregisterSnapshotEnricher(name) {
+    this.snapshotExtras.delete(name);
+  }
+  // ============================================================================
   // Element Management
   // ============================================================================
   /**
@@ -418,7 +443,7 @@ var NativeUIBridgeRegistry = class {
       const currentRoute = routeInfo.currentRoute;
       elements = elements.filter((e) => e.registrationRoute === currentRoute);
     }
-    return {
+    const snapshot = {
       timestamp: Date.now(),
       elements: elements.map((e) => {
         const handlers = extractHandlerNames(e.props);
@@ -450,6 +475,49 @@ var NativeUIBridgeRegistry = class {
       currentRoute: routeInfo?.currentRoute ?? null,
       segments: routeInfo?.segments
     };
+    if (this.enrichers.modalDetector) {
+      try {
+        snapshot.modalStack = this.enrichers.modalDetector.getSnapshotModalContext();
+      } catch (error3) {
+        if (this.config.verbose) {
+          console.warn(`[ui-bridge-native] modalDetector enricher threw:`, error3);
+        }
+      }
+    }
+    if (this.enrichers.toastCapture) {
+      try {
+        snapshot.toasts = this.enrichers.toastCapture.getSnapshotToastContext();
+      } catch (error3) {
+        if (this.config.verbose) {
+          console.warn(`[ui-bridge-native] toastCapture enricher threw:`, error3);
+        }
+      }
+    }
+    if (this.enrichers.undoTracker) {
+      try {
+        snapshot.undoRedo = this.enrichers.undoTracker.getSnapshotUndoContext();
+      } catch (error3) {
+        if (this.config.verbose) {
+          console.warn(`[ui-bridge-native] undoTracker enricher threw:`, error3);
+        }
+      }
+    }
+    if (this.snapshotExtras.size > 0) {
+      const ctx = { elements, currentRoute: routeInfo?.currentRoute ?? null };
+      for (const [name, fn] of this.snapshotExtras) {
+        try {
+          const extra = fn(ctx);
+          if (extra && typeof extra === "object") {
+            Object.assign(snapshot, extra);
+          }
+        } catch (error3) {
+          if (this.config.verbose) {
+            console.warn(`[ui-bridge-native] snapshot enricher "${name}" threw:`, error3);
+          }
+        }
+      }
+    }
+    return snapshot;
   }
   /**
    * Get registry statistics
@@ -543,6 +611,23 @@ function sleep(ms) {
 var DefaultNativeActionExecutor = class {
   constructor(registry) {
     this.registry = registry;
+    this.actionListeners = /* @__PURE__ */ new Set();
+  }
+  onActionExecuted(listener) {
+    this.actionListeners.add(listener);
+    return () => {
+      this.actionListeners.delete(listener);
+    };
+  }
+  /** Notify listeners out-of-band; isolate each invocation so one bad listener can't poison the rest. */
+  emitActionEvent(event) {
+    for (const listener of this.actionListeners) {
+      try {
+        listener(event);
+      } catch (error3) {
+        console.warn(`[ui-bridge-native] Action listener error:`, error3);
+      }
+    }
   }
   /**
    * Execute an action on an element
@@ -556,11 +641,23 @@ var DefaultNativeActionExecutor = class {
         registered = findElementByIdentifier(elementId) ?? void 0;
       }
       if (!registered) {
+        const failTime = Date.now();
+        const errorMsg = `Element not found: ${elementId}`;
+        this.emitActionEvent({
+          elementId,
+          action: request.action,
+          params: request.params,
+          success: false,
+          error: errorMsg,
+          timestamp: failTime,
+          requestId: request.requestId,
+          durationMs: failTime - startTime
+        });
         return {
           success: false,
-          error: `Element not found: ${elementId}`,
-          durationMs: Date.now() - startTime,
-          timestamp: Date.now(),
+          error: errorMsg,
+          durationMs: failTime - startTime,
+          timestamp: failTime,
           requestId: request.requestId
         };
       }
@@ -568,33 +665,67 @@ var DefaultNativeActionExecutor = class {
         const waitResult = await this.waitForElementInternal(registered.id, request.waitOptions);
         waitDurationMs = waitResult.waitedMs;
         if (!waitResult.met) {
+          const failTime = Date.now();
+          const errorMsg = waitResult.error || "Wait condition not met";
+          this.emitActionEvent({
+            elementId,
+            action: request.action,
+            params: request.params,
+            success: false,
+            error: errorMsg,
+            timestamp: failTime,
+            requestId: request.requestId,
+            durationMs: failTime - startTime
+          });
           return {
             success: false,
-            error: waitResult.error || "Wait condition not met",
-            durationMs: Date.now() - startTime,
-            timestamp: Date.now(),
+            error: errorMsg,
+            durationMs: failTime - startTime,
+            timestamp: failTime,
             requestId: request.requestId,
             waitDurationMs
           };
         }
       }
       const result = await this.performAction(registered, request.action, request.params);
+      const successTime = Date.now();
+      this.emitActionEvent({
+        elementId,
+        action: request.action,
+        params: request.params,
+        success: true,
+        timestamp: successTime,
+        requestId: request.requestId,
+        durationMs: successTime - startTime
+      });
       return {
         success: true,
         elementState: registered.getState(),
         result,
-        durationMs: Date.now() - startTime,
-        timestamp: Date.now(),
+        durationMs: successTime - startTime,
+        timestamp: successTime,
         requestId: request.requestId,
         waitDurationMs
       };
     } catch (error3) {
+      const failTime = Date.now();
+      const errorMsg = error3 instanceof Error ? error3.message : String(error3);
+      this.emitActionEvent({
+        elementId,
+        action: request.action,
+        params: request.params,
+        success: false,
+        error: errorMsg,
+        timestamp: failTime,
+        requestId: request.requestId,
+        durationMs: failTime - startTime
+      });
       return {
         success: false,
-        error: error3 instanceof Error ? error3.message : String(error3),
+        error: errorMsg,
         stack: error3 instanceof Error ? error3.stack : void 0,
-        durationMs: Date.now() - startTime,
-        timestamp: Date.now(),
+        durationMs: failTime - startTime,
+        timestamp: failTime,
         requestId: request.requestId,
         waitDurationMs
       };
@@ -687,7 +818,7 @@ var DefaultNativeActionExecutor = class {
     if (!params?.text) {
       throw new Error("Type action requires text parameter");
     }
-    if (params.clearFirst) {
+    if (params.clearFirst || params.clear) {
       await this.performClear(element, props);
     }
     if (params.delay && params.delay > 0) {
@@ -1873,6 +2004,15 @@ function createServerHandlers(registry, executor, config) {
         timestamp: Date.now(),
         ...stats
       };
+      if (config?.appInfo) {
+        response.uiBridge = {
+          version: "0.3.0",
+          ...config.appInfo,
+          capabilities: ["elements", "components", "actions", "design"],
+          elementCount: stats.elements,
+          componentCount: stats.components
+        };
+      }
       return success2(response);
     }
   };
@@ -1911,6 +2051,10 @@ var WS_ROUTES = [
   { pattern: "health", handler: "health", httpMethods: ["GET"] },
   // Elements
   { pattern: "control/elements", handler: "getElements", httpMethods: ["GET"] },
+  // Flat alias — matches the runner UI Bridge's `/ui-bridge/elements` path so
+  // agents can use the same URL across runner + mobile without remembering
+  // the `control/` prefix. Delegates to the same handler.
+  { pattern: "elements", handler: "getElements", httpMethods: ["GET"] },
   { pattern: "control/element/:id", handler: "getElement", httpMethods: ["GET"] },
   { pattern: "control/element/:id/state", handler: "getElementState", httpMethods: ["GET"] },
   { pattern: "control/element/:id/action", handler: "executeAction", httpMethods: ["POST"] },
@@ -1961,6 +2105,87 @@ var WS_ROUTES = [
   // Meta / Introspection
   { pattern: "meta/methods", handler: "getMethods", httpMethods: ["GET"] }
 ];
+var HANDLER_DESCRIPTIONS = {
+  health: "Liveness probe; returns app metadata + element count",
+  getElements: "Flat list of registered UI elements",
+  getElement: "Single element by id",
+  getElementState: "Dynamic state (value, focused, checked) for one element",
+  executeAction: 'Run an action on an element (see "actions" below for names)',
+  getComponents: "Higher-level components with action schemas",
+  getComponent: "Component detail + per-action paramSchema",
+  executeComponentAction: "Invoke a component action directly (preferred over button clicks)",
+  find: "AI-powered element search by natural-language query",
+  getSnapshot: "Full snapshot: elements + route + state. Supports ?visibleOnly=true and ?currentRouteOnly=true",
+  getWorkflows: "List registered workflows",
+  runWorkflow: "Trigger a workflow by id",
+  pageRefresh: "Reload the current route",
+  pageNavigate: "Imperative router.push(url) \u2014 preferred over tapping tab buttons",
+  pageReplace: "router.replace(url)",
+  pageGoBack: "router.back()",
+  pageGoForward: "router.forward()",
+  getScreenshot: "PNG screenshot of the current screen",
+  getElementStyles: "Computed styles for an element (design review)",
+  getElementStateStyles: "Computed styles per interaction state (hover/focus/disabled)",
+  getDesignSnapshot: "Visual + style snapshot for design review",
+  getResponsiveSnapshots: "Screenshots at multiple viewport widths",
+  runDesignAudit: "Accessibility + visual audit",
+  loadStyleGuide: "Load a design system style guide",
+  getStyleGuide: "Fetch the currently loaded style guide",
+  clearStyleGuide: "Unload the style guide",
+  evaluateQuality: "Score the current UI against a quality context",
+  getQualityContexts: "List available quality evaluation contexts",
+  saveBaseline: "Save a quality baseline snapshot",
+  diffBaseline: "Diff current UI against a saved baseline",
+  getMethods: "List every handler name (legacy introspection)"
+};
+var ACTION_REFERENCE = [
+  { name: "press", aliases: ["click"], params: "PressActionParams (optional position)" },
+  { name: "longPress", params: "PressActionParams (optional position)" },
+  { name: "doubleTap", params: "none" },
+  {
+    name: "type",
+    params: "TypeActionParams { text, delay?, clear? | clearFirst? } \u2014 `clear:true` replaces content atomically"
+  },
+  { name: "clear", params: "none \u2014 empties the input" },
+  { name: "focus", params: "none" },
+  { name: "blur", params: "none" },
+  { name: "scroll", params: "ScrollActionParams { offset? {x,y}, to? }" },
+  { name: "swipe", params: "SwipeActionParams { direction, distance }" },
+  { name: "toggle", params: "none \u2014 flips boolean controls" }
+];
+function buildRoutesPayload() {
+  const entries = [];
+  for (const r of WS_ROUTES) {
+    if (!r.httpMethods) continue;
+    for (const m of r.httpMethods) {
+      entries.push({ method: m, path: `/ui-bridge/${r.pattern}` });
+    }
+  }
+  entries.push({ method: "GET", path: "/ui-bridge/_help" });
+  entries.push({ method: "GET", path: "/ui-bridge/_routes" });
+  entries.sort((a, b) => a.path.localeCompare(b.path) || a.method.localeCompare(b.method));
+  return { routes: entries, count: entries.length };
+}
+function buildHelpPayload() {
+  return {
+    version: 1,
+    description: "UI Bridge Native HTTP surface. Prefix every path with /ui-bridge/.",
+    routes: WS_ROUTES.map((r) => ({
+      pattern: r.pattern,
+      httpMethods: r.httpMethods ?? [],
+      wsOnly: !r.httpMethods,
+      handler: r.handler,
+      description: HANDLER_DESCRIPTIONS[r.handler] ?? ""
+    })),
+    actions: ACTION_REFERENCE,
+    tips: [
+      "Start with `GET /ui-bridge/control/snapshot?visibleOnly=true` to see what the user actually sees.",
+      "Prefer `control/component/:id/action/:actionId` over button presses \u2014 typed paramSchema, no button-id guessing.",
+      "Use `pageNavigate` for tab switches instead of pressing tab buttons; gesture state often swallows clicks.",
+      "The `type` action supports `clear:true` to replace existing text atomically in one call."
+    ]
+  };
+}
 var NativeUIBridgeServer = class {
   constructor(registry, executor, config = {}) {
     this.registry = registry;
@@ -1977,7 +2202,9 @@ var NativeUIBridgeServer = class {
       cors: true,
       ...config
     };
-    this.handlers = createServerHandlers(registry, executor);
+    this.handlers = createServerHandlers(registry, executor, {
+      appInfo: this.config.appInfo
+    });
     this.handlers.getMethods = async () => {
       const methods = WS_ROUTES.map((r) => ({
         method: r.pattern,
@@ -2781,6 +3008,20 @@ var NativeUIBridgeServer = class {
       };
     }
     const stripped = path.slice(PREFIX.length);
+    if (method === "GET" && stripped === "_help") {
+      return {
+        success: true,
+        data: buildHelpPayload(),
+        timestamp: Date.now()
+      };
+    }
+    if (method === "GET" && stripped === "_routes") {
+      return {
+        success: true,
+        data: buildRoutesPayload(),
+        timestamp: Date.now()
+      };
+    }
     let patternMatchedButWrongVerb = false;
     for (const route of WS_ROUTES) {
       const pathParams = parsePath(route.pattern, stripped);
@@ -3402,6 +3643,186 @@ function parseQueryParams(path) {
   }
   return result;
 }
+
+// src/modal/modal-detector.ts
+var ModalDetector = class {
+  constructor() {
+    /** Map preserves O(1) idempotent replace by id; ordering comes from detectedAt. */
+    this.modals = /* @__PURE__ */ new Map();
+  }
+  pushModal(modal) {
+    const existing = this.modals.get(modal.id);
+    const detectedAt = existing ? existing.detectedAt : Date.now();
+    const next = {
+      id: modal.id,
+      title: modal.title,
+      type: modal.type ?? "modal",
+      blocking: modal.blocking ?? true,
+      dismissible: modal.dismissible ?? true,
+      detectedAt
+    };
+    this.modals.set(modal.id, next);
+  }
+  dismissModal(id) {
+    this.modals.delete(id);
+  }
+  getSnapshotModalContext() {
+    const active = this.getActive();
+    const ctx = {
+      modals: active,
+      hasBlockingModal: active.some((m) => m.blocking),
+      count: active.length
+    };
+    if (active.length > 0) {
+      ctx.topModal = active[active.length - 1];
+    }
+    return ctx;
+  }
+  getActive() {
+    return Array.from(this.modals.values()).sort((a, b) => a.detectedAt - b.detectedAt);
+  }
+  clear() {
+    this.modals.clear();
+  }
+};
+
+// src/toast/toast-capture.ts
+var DEFAULT_MAX_RECENT = 50;
+var ToastCapture = class {
+  constructor(config = {}) {
+    this.active = /* @__PURE__ */ new Map();
+    this.recent = [];
+    this.totalCaptured = 0;
+    this.maxRecent = config.maxRecent ?? DEFAULT_MAX_RECENT;
+  }
+  recordToast(toast) {
+    if (this.active.has(toast.id)) {
+      return;
+    }
+    const appearedAt = toast.appearedAt ?? Date.now();
+    const entry = {
+      id: toast.id,
+      message: toast.message,
+      level: toast.level ?? "info",
+      appearedAt,
+      visible: true,
+      durationMs: 0
+    };
+    this.active.set(toast.id, entry);
+    this.totalCaptured += 1;
+  }
+  dismissToast(id) {
+    const entry = this.active.get(id);
+    if (!entry) {
+      return;
+    }
+    this.active.delete(id);
+    const dismissedAt = Date.now();
+    const dismissed = {
+      ...entry,
+      dismissedAt,
+      visible: false,
+      durationMs: dismissedAt - entry.appearedAt
+    };
+    this.recent.push(dismissed);
+    if (this.recent.length > this.maxRecent) {
+      this.recent.shift();
+    }
+  }
+  getSnapshotToastContext() {
+    const now = Date.now();
+    const active = Array.from(this.active.values()).map((entry) => ({
+      ...entry,
+      durationMs: now - entry.appearedAt
+    }));
+    return {
+      active,
+      recent: [...this.recent],
+      totalCaptured: this.totalCaptured
+    };
+  }
+  clear() {
+    this.active.clear();
+    this.recent = [];
+    this.totalCaptured = 0;
+  }
+};
+
+// src/undo/undo-tracker.ts
+var DEFAULT_MAX_HISTORY = 50;
+function buildSummary(ctx) {
+  if (!ctx.canUndo && !ctx.canRedo) {
+    return "no undo available";
+  }
+  const parts = [];
+  if (ctx.canUndo) {
+    parts.push(`undo: '${ctx.undoDescription ?? "available"}'`);
+  }
+  if (ctx.canRedo) {
+    parts.push(`redo: '${ctx.redoDescription ?? "available"}'`);
+  }
+  return parts.join(" / ");
+}
+var UndoTracker = class {
+  constructor(config = {}) {
+    this.actions = [];
+    this.declaredState = null;
+    this.maxHistory = config.maxHistory ?? DEFAULT_MAX_HISTORY;
+  }
+  recordAction(record) {
+    this.actions.push(record);
+    if (this.actions.length > this.maxHistory) {
+      this.actions = this.actions.slice(-this.maxHistory);
+    }
+  }
+  setDeclaredState(state) {
+    this.declaredState = state;
+  }
+  getActionHistory() {
+    return this.actions.slice();
+  }
+  getSnapshotUndoContext() {
+    const declared = this.declaredState;
+    if (declared) {
+      const summary2 = buildSummary({
+        canUndo: declared.canUndo,
+        canRedo: declared.canRedo,
+        undoDescription: declared.undoDescription,
+        redoDescription: declared.redoDescription
+      });
+      return {
+        canUndo: declared.canUndo,
+        canRedo: declared.canRedo,
+        undoDescription: declared.undoDescription,
+        redoDescription: declared.redoDescription,
+        undoDepth: declared.undoDepth,
+        redoDepth: declared.redoDepth,
+        summary: summary2
+      };
+    }
+    const canUndo = this.actions.some((a) => a.reversible !== false);
+    const canRedo = false;
+    const lastReversible = [...this.actions].reverse().find((a) => a.reversible !== false);
+    const undoDescription = lastReversible?.description;
+    const summary = buildSummary({ canUndo, canRedo, undoDescription });
+    return {
+      canUndo,
+      canRedo,
+      undoDescription,
+      summary
+    };
+  }
+  executeUndo() {
+    return { ok: false, reason: "Not implemented in native" };
+  }
+  executeRedo() {
+    return { ok: false, reason: "Not implemented in native" };
+  }
+  clear() {
+    this.actions = [];
+    this.declaredState = null;
+  }
+};
 var UIBridgeNativeContext = createContext(null);
 function UIBridgeNativeProvider({
   children,
@@ -3418,6 +3839,9 @@ function UIBridgeNativeProvider({
 }) {
   const registryRef = useRef(null);
   const executorRef = useRef(null);
+  const modalDetectorRef = useRef(null);
+  const toastCaptureRef = useRef(null);
+  const undoTrackerRef = useRef(null);
   const [serverRunning, setServerRunning] = useState(false);
   if (!registryRef.current) {
     registryRef.current = new NativeUIBridgeRegistry({
@@ -3431,6 +3855,12 @@ function UIBridgeNativeProvider({
     executorRef.current = createNativeActionExecutor(registry);
   }
   const executor = executorRef.current;
+  if (!modalDetectorRef.current) modalDetectorRef.current = new ModalDetector();
+  if (!toastCaptureRef.current) toastCaptureRef.current = new ToastCapture();
+  if (!undoTrackerRef.current) undoTrackerRef.current = new UndoTracker();
+  const modalDetector = modalDetectorRef.current;
+  const toastCapture = toastCaptureRef.current;
+  const undoTracker = undoTrackerRef.current;
   const serverRef = useRef(null);
   const eventBridgeRef = useRef(null);
   const announcerRef = useRef(null);
@@ -3445,7 +3875,8 @@ function UIBridgeNativeProvider({
     }
     const server = createNativeServer(registry, executor, {
       serverPort: config.serverPort || 8087,
-      cors: true
+      cors: true,
+      appInfo: config.appInfo
     });
     server.setAdapter(serverAdapter);
     if (navigationProvider) {
@@ -3532,7 +3963,8 @@ function UIBridgeNativeProvider({
         try {
           const bareServer = createNativeServer(registry, executor, {
             serverPort: config.serverPort || 8087,
-            cors: true
+            cors: true,
+            appInfo: config.appInfo
           });
           if (navigationProvider) bareServer.setNavigationProvider(navigationProvider);
           if (screenshotProvider) bareServer.setScreenshotProvider(screenshotProvider);
@@ -3617,6 +4049,22 @@ function UIBridgeNativeProvider({
       lastRoute = current;
     });
   }, [routeProvider, registry]);
+  useEffect(() => {
+    registry.setEnrichers({ modalDetector, toastCapture, undoTracker });
+  }, [registry, modalDetector, toastCapture, undoTracker]);
+  useEffect(() => {
+    const unsubscribe = executor.onActionExecuted((event) => {
+      if (!event.success) return;
+      undoTracker.recordAction({
+        id: event.requestId ?? `action-${event.timestamp}`,
+        type: event.action,
+        targetId: event.elementId,
+        timestamp: event.timestamp,
+        reversible: true
+      });
+    });
+    return unsubscribe;
+  }, [executor, undoTracker]);
   const on = useCallback(
     (type, listener) => registry.on(type, listener),
     [registry]
@@ -3631,6 +4079,9 @@ function UIBridgeNativeProvider({
       config,
       registry,
       executor,
+      modalDetector,
+      toastCapture,
+      undoTracker,
       getElements,
       getComponents,
       createSnapshot,
@@ -3647,6 +4098,9 @@ function UIBridgeNativeProvider({
       config,
       registry,
       executor,
+      modalDetector,
+      toastCapture,
+      undoTracker,
       getElements,
       getComponents,
       createSnapshot,
@@ -4164,7 +4618,38 @@ function useAutoRegister(options = {}) {
     isEnabled: enabled && !!bridge?.registry
   };
 }
+function useUIBridgeModal(opts) {
+  const { modalDetector } = useUIBridgeNative();
+  const { id, title, type, blocking, dismissible } = opts;
+  useEffect(() => {
+    modalDetector.pushModal({ id, title, type, blocking, dismissible });
+    return () => {
+      modalDetector.dismissModal(id);
+    };
+  }, [modalDetector, id, title, type, blocking, dismissible]);
+}
+function useUIBridgeToast(opts) {
+  const { toastCapture } = useUIBridgeNative();
+  const { id, message, level } = opts;
+  useEffect(() => {
+    toastCapture.recordToast({ id, message, level });
+    return () => {
+      toastCapture.dismissToast(id);
+    };
+  }, [toastCapture, id, message, level]);
+}
+function useToastRecorder() {
+  const { toastCapture } = useUIBridgeNative();
+  const recordToast = useCallback(
+    (toast) => {
+      toastCapture.recordToast(toast);
+    },
+    [toastCapture]
+  );
+  const dismissToast = useCallback((id) => toastCapture.dismissToast(id), [toastCapture]);
+  return { recordToast, dismissToast };
+}
 
-export { UIBridgeNativeProvider, useAutoRegister, useUIBridge, useUIBridgeNative, useUIBridgeNativeOptional, useUIBridgeNativeRequired, useUIBridgeRequired, useUIComponent, useUIComponentAction, useUIElement, useUIElementWithProps };
+export { UIBridgeNativeProvider, useAutoRegister, useToastRecorder, useUIBridge, useUIBridgeModal, useUIBridgeNative, useUIBridgeNativeOptional, useUIBridgeNativeRequired, useUIBridgeRequired, useUIBridgeToast, useUIComponent, useUIComponentAction, useUIElement, useUIElementWithProps };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map