@qontinui/ui-bridge-native 0.3.2 → 0.4.0

package/dist/http-server-C9NaNBEP.d.ts

@@ -1,805 +0,0 @@
-import { a as NativeUIBridgeRegistry } from './registry-pAUpQq2O.js';
-import { c as ComponentActionResponse, e as PageNavigationResponse, N as NativeActionExecutor } from './types-CjEKTDYT.js';
-import { x as NativeUIBridgeConfig, d as NativeActionResponse, n as NativeFindResponse, e as NativeBridgeSnapshot } from './types-CGVut7mc.js';
-import { E as ElementDesignData, S as StateStyles, R as ResponsiveSnapshot } from './design-types-BHr6Q1FX.js';
-
-/**
- * UI Bridge Native Server Types
- *
- * Types for the embedded HTTP server.
- */
-
-/**
- * Navigation provider for React Native apps.
- *
- * Apps supply this to enable programmatic navigation via the UI Bridge
- * (e.g., `control/page/navigate` and `control/page/back`).
- * For Expo Router: pass `router.push` and `router.back`.
- */
-interface NavigationProvider {
-    navigate: (url: string) => void;
-    back?: () => void;
-    /** Replace current route (no back-stack entry). For Expo Router: router.replace */
-    replace?: (url: string) => void;
-    /** Refresh the current route. For Expo Router: router.replace(currentPath) */
-    refresh?: () => void;
-}
-/**
- * Screenshot provider for React Native apps.
- *
- * Apps supply this to enable screen capture via the UI Bridge
- * (`control/screenshot`). For react-native-view-shot: pass a function
- * that calls `captureRef` on the root view and returns base64 PNG data.
- */
-interface ScreenshotProvider {
-    /** Capture the current screen and return base64-encoded PNG data (no data: prefix). */
-    capture: () => Promise<{
-        base64: string;
-        width: number;
-        height: number;
-    }>;
-}
-/**
- * Route provider for React Native apps.
- *
- * Apps supply this to expose the current navigation route in UI Bridge snapshots.
- * For Expo Router: render a RouteTracker component inside the router context that
- * calls `usePathname()` / `useSegments()` and writes the result to a module-level ref.
- */
-interface RouteProvider {
-    /** Return the current route path (e.g. "/(tabs)/runs"), or null if unknown. */
-    getCurrentRoute: () => string | null;
-    /** Return the current route segments (e.g. ["(tabs)", "runs"]), if available. */
-    getSegments?: () => string[];
-    /**
-     * Subscribe to route changes. Required so the UI Bridge can clear stale
-     * layouts on route changes with zero lag.
-     *
-     * Implementers must invoke `listener` synchronously whenever the route
-     * changes, passing the new route (or null if unknown). The returned function
-     * must unsubscribe the listener.
-     *
-     * For Expo Router: wrap your RouteTracker component in a module-level
-     * listener set and call each listener from within the tracker's effect.
-     */
-    subscribe: (listener: (route: string | null) => void) => () => void;
-}
-/**
- * Server configuration
- */
-interface NativeServerConfig extends NativeUIBridgeConfig {
-    /** Enable CORS */
-    cors?: boolean;
-    /** Allowed origins for CORS */
-    allowedOrigins?: string[];
-    /**
-     * Enable test-only HTTP endpoints (currently `control/modal/push` and
-     * `control/modal/dismiss/:id`) so external runners can drive registry
-     * state. Default `false`; the React provider mirrors
-     * `features.testHooks` into this slot.
-     */
-    testHooks?: boolean;
-}
-/**
- * Route definition
- */
-interface RouteDefinition {
-    method: 'GET' | 'POST' | 'PUT' | 'DELETE';
-    path: string;
-    description: string;
-}
-/**
- * All UI Bridge Native routes
- */
-declare const UI_BRIDGE_NATIVE_ROUTES: Record<string, RouteDefinition>;
-/**
- * Request body for `POST /ai/fill-form`.
- *
- * The mobile native bridge has no `setValue` action — text inputs are driven
- * via the `type` action (which calls `onChangeText`). The fillForm handler
- * dispatches each field as `executor.executeAction(elementId, { action: 'type',
- * params: { text: value, clear: true } })` so existing values are atomically
- * replaced (matching the web bridge's "setValue" semantics).
- *
- * Shape mirrors the runner's `POST /ui-bridge/ai/fill-form` documented in
- * docs-site/api/runner-features.md (array-of-pairs form), so callers can use
- * the same JSON across mobile and web/runner without special-casing.
- */
-interface FillFormFieldInput {
-    /** Target element id (registered id, testID, accessibilityLabel, etc.) */
-    elementId: string;
-    /** Text value to write into the input. */
-    value: string;
-}
-interface FillFormRequest {
-    fields: FillFormFieldInput[];
-}
-/**
- * Per-field outcome returned by `POST /ai/fill-form`.
- */
-interface FillFormFieldResult {
-    /** Element id from the request, echoed back. */
-    elementId: string;
-    /** Whether `executor.executeAction` reported success for this field. */
-    success: boolean;
-    /** Error message when `success === false`. Omitted on success. */
-    error?: string;
-}
-/**
- * Response payload returned in `APIResponse.data` for `POST /ai/fill-form`.
- */
-interface FillFormResponse {
-    results: FillFormFieldResult[];
-    succeededCount: number;
-    failedCount: number;
-}
-/**
- * Request body for `POST /control/tap` — synthesize a press at given screen
- * coordinates by searching registered elements whose layout rect contains the
- * point.
- *
- * The handler picks the topmost (smallest-area) match — usually the innermost
- * child — then dispatches the requested action via the standard executor.
- * `action` defaults to `'press'`.
- */
-interface TapAtRequest {
-    x: number;
-    y: number;
-    action?: 'press' | 'longPress' | 'doubleTap';
-}
-/**
- * Response payload returned in `APIResponse.data` for `POST /control/tap`.
- */
-interface TapAtResponse {
-    /** Element id whose rect contained the tap coords. */
-    elementId: string;
-    /** Action that was dispatched. */
-    action: 'press' | 'longPress' | 'doubleTap';
-    /** The element's layout rect at dispatch time (best-effort). */
-    layout: {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-        pageX?: number;
-        pageY?: number;
-    } | null;
-}
-/**
- * Single console error/warn entry captured by the observability ring buffer.
- * Returned by `GET /control/console-errors`.
- */
-interface ConsoleErrorEntry {
-    /** ms since epoch when the entry was captured. */
-    timestamp: number;
-    /** `'error'` or `'warn'`. */
-    level: 'error' | 'warn';
-    /** Joined message string (matches what console would have printed). */
-    message: string;
-    /** Captured stack trace if any of the args was an Error. */
-    stack?: string;
-}
-/**
- * Response payload for `GET /control/console-errors`.
- */
-interface ConsoleErrorsResponse {
-    entries: ConsoleErrorEntry[];
-    /** Number of entries returned (post `since`/`limit` filtering). */
-    count: number;
-    /** Total entries currently held in the ring buffer (pre-filter). */
-    bufferSize: number;
-}
-/**
- * Single network request entry captured by the observability ring buffer.
- * Returned by `GET /sdk/network-requests`.
- */
-interface NetworkRequestEntry {
-    /** ms since epoch at request start. */
-    timestamp: number;
-    /** HTTP method (uppercased). */
-    method: string;
-    /** Resolved request URL. */
-    url: string;
-    /** HTTP status code, or 0 if the request errored before a response. */
-    status: number;
-    /** Wall-clock duration in ms from start to settlement. */
-    durationMs: number;
-    /** Whether the request settled with a 2xx response. */
-    ok: boolean;
-    /** Error message when the request rejected before a response. */
-    error?: string;
-}
-/**
- * Response payload for `GET /sdk/network-requests`.
- */
-interface NetworkRequestsResponse {
-    entries: NetworkRequestEntry[];
-    count: number;
-    bufferSize: number;
-}
-/**
- * Request body for `POST /control/modal/push`.
- *
- * Mirrors `ModalDetector.pushModal`'s `ModalPushInput` shape; `metadata` is
- * a free-form object the test runner can stash for later assertions but is
- * not currently surfaced in the snapshot.
- */
-interface PushModalRequest {
-    id: string;
-    title?: string;
-    type?: string;
-    blocking?: boolean;
-    dismissible?: boolean;
-    metadata?: Record<string, unknown>;
-}
-/**
- * Response payload for `POST /control/modal/push`.
- */
-interface PushModalResponse {
-    pushed: boolean;
-    id: string;
-    title?: string;
-    type?: string;
-    blocking?: boolean;
-    dismissible?: boolean;
-    pushedAt: number;
-}
-/**
- * Response payload for `POST /control/modal/dismiss/:id`.
- */
-interface DismissModalResponse {
-    dismissed: string;
-}
-/**
- * API response wrapper
- */
-interface APIResponse<T = unknown> {
-    success: boolean;
-    data?: T;
-    error?: string;
-    code?: string;
-    timestamp: number;
-}
-/**
- * Handler context
- */
-interface HandlerContext {
-    params: Record<string, string>;
-    query: Record<string, string>;
-    body: unknown;
-}
-/**
- * Handler function type
- */
-type HandlerFunction<T = unknown> = (context: HandlerContext) => Promise<APIResponse<T>>;
-/**
- * Server handlers interface
- */
-interface NativeServerHandlers {
-    getElements: HandlerFunction<{
-        elements: unknown[];
-    }>;
-    getElement: HandlerFunction<{
-        element: unknown;
-    }>;
-    getElementState: HandlerFunction<{
-        state: unknown;
-    }>;
-    executeAction: HandlerFunction<NativeActionResponse>;
-    getComponents: HandlerFunction<{
-        components: unknown[];
-    }>;
-    getComponent: HandlerFunction<{
-        component: unknown;
-    }>;
-    executeComponentAction: HandlerFunction<ComponentActionResponse>;
-    find: HandlerFunction<NativeFindResponse>;
-    getSnapshot: HandlerFunction<NativeBridgeSnapshot>;
-    getWorkflows: HandlerFunction<{
-        workflows: unknown[];
-    }>;
-    runWorkflow: HandlerFunction<{
-        runId: string;
-        status: string;
-        steps: Array<{
-            stepId: string;
-            type: string;
-            status: string;
-            result?: unknown;
-            error?: string;
-            durationMs: number;
-        }>;
-        totalSteps: number;
-        completedSteps: number;
-        failedSteps: number;
-        skippedSteps: number;
-        durationMs: number;
-    }>;
-    pageRefresh: HandlerFunction<PageNavigationResponse>;
-    pageNavigate: HandlerFunction<PageNavigationResponse>;
-    pageReplace: HandlerFunction<PageNavigationResponse>;
-    pageGoBack: HandlerFunction<PageNavigationResponse>;
-    pageGoForward: HandlerFunction<PageNavigationResponse>;
-    getScreenshot: HandlerFunction<{
-        screenshot: string;
-        width: number;
-        height: number;
-    }>;
-    getElementStyles: HandlerFunction<ElementDesignData>;
-    getElementStateStyles: HandlerFunction<{
-        elementId: string;
-        stateStyles: StateStyles[];
-    }>;
-    getDesignSnapshot: HandlerFunction<{
-        elements: ElementDesignData[];
-        timestamp: number;
-    }>;
-    getResponsiveSnapshots: HandlerFunction<ResponsiveSnapshot[]>;
-    runDesignAudit: HandlerFunction<unknown>;
-    loadStyleGuide: HandlerFunction<{
-        loaded: boolean;
-    }>;
-    getStyleGuide: HandlerFunction<unknown>;
-    clearStyleGuide: HandlerFunction<{
-        cleared: boolean;
-    }>;
-    evaluateQuality: HandlerFunction<unknown>;
-    getQualityContexts: HandlerFunction<Array<{
-        name: string;
-        description: string;
-    }>>;
-    saveBaseline: HandlerFunction<{
-        saved: boolean;
-        elementCount: number;
-    }>;
-    diffBaseline: HandlerFunction<unknown>;
-    getMethods: HandlerFunction<{
-        methods: Array<{
-            method: string;
-            httpMethods?: string[];
-            description?: string;
-        }>;
-    }>;
-    fillForm: HandlerFunction<FillFormResponse>;
-    tapAt: HandlerFunction<TapAtResponse>;
-    getConsoleErrors: HandlerFunction<ConsoleErrorsResponse>;
-    getNetworkRequests: HandlerFunction<NetworkRequestsResponse>;
-    pushModal: HandlerFunction<PushModalResponse>;
-    dismissModal: HandlerFunction<DismissModalResponse>;
-    health: HandlerFunction<Record<string, unknown>>;
-}
-
-/**
- * WebSocket JSON-RPC message types for the UI Bridge protocol.
- */
-/** Standard JSON-RPC request */
-interface JsonRpcRequest {
-    id: number | string;
-    method: string;
-    params?: Record<string, unknown>;
-}
-/** Batch request — execute multiple requests concurrently */
-interface JsonRpcBatchRequest {
-    id: number | string;
-    batch: JsonRpcRequest[];
-}
-/** Subscribe to registry events */
-interface JsonRpcSubscribe {
-    id: number | string;
-    method: 'subscribe';
-    params: {
-        events: string[];
-        /** Optional throttle in ms — batch rapid events within this window */
-        throttleMs?: number;
-    };
-}
-/** Unsubscribe from registry events */
-interface JsonRpcUnsubscribe {
-    id: number | string;
-    method: 'unsubscribe';
-    params: {
-        events: string[];
-    };
-}
-/** Any client message */
-type JsonRpcClientMessage = JsonRpcRequest | JsonRpcBatchRequest | JsonRpcSubscribe | JsonRpcUnsubscribe;
-/** Standard JSON-RPC response */
-interface JsonRpcResponse {
-    id: number | string;
-    result?: {
-        success: boolean;
-        data?: unknown;
-        error?: string;
-        code?: string;
-        timestamp?: number;
-    };
-}
-/** Batch response */
-interface JsonRpcBatchResponse {
-    id: number | string;
-    results: JsonRpcResponse[];
-}
-/** Server-pushed event (no id — not a response to a request) */
-interface JsonRpcEvent {
-    event: string;
-    data: unknown;
-    timestamp: number;
-}
-/** Any server message */
-type JsonRpcServerMessage = JsonRpcResponse | JsonRpcBatchResponse | JsonRpcEvent;
-/** Check if a message is a batch request */
-declare function isBatchRequest(msg: unknown): msg is JsonRpcBatchRequest;
-/** Check if a message is a subscribe request */
-declare function isSubscribe(msg: unknown): msg is JsonRpcSubscribe;
-/** Check if a message is an unsubscribe request */
-declare function isUnsubscribe(msg: unknown): msg is JsonRpcUnsubscribe;
-
-/**
- * WebSocket connection wrapper for the UI Bridge server.
- *
- * Manages a single WebSocket connection after the HTTP upgrade handshake,
- * handling frame-level I/O, heartbeat, and event subscriptions.
- */
-
-/**
- * Callback for text messages received from the client.
- * Returns a response string to send back, or null for no response.
- */
-type WebSocketMessageHandler = (connId: string, message: string) => Promise<string | null>;
-declare class WebSocketConnection {
-    readonly id: string;
-    readonly subscriptions: Set<string>;
-    /** Heartbeat liveness flag — set false before ping, set true on pong */
-    alive: boolean;
-    private socket;
-    private buffer;
-    private fragmentBuffer;
-    private fragmentOpcode;
-    private closed;
-    private onMessage;
-    private onClose;
-    constructor(id: string, socket: WebSocketConnection['socket'], onMessage: WebSocketMessageHandler, onClose: (connId: string) => void);
-    /** Send a text message to the client. */
-    send(message: string): void;
-    /**
-     * Send an event if the client is subscribed to it. Subscription patterns
-     * may be exact event names, `*` (all), or glob patterns containing `*`
-     * (e.g. `element:*`, `*:stateChanged`). Exact matches and `*` are checked
-     * via fast Set lookups; glob patterns fall through to a regex test.
-     */
-    sendEvent(event: JsonRpcEvent): void;
-    private matchesSubscription;
-    /** Send a ping frame for heartbeat. */
-    ping(): void;
-    /** Close the connection gracefully. */
-    close(code?: number, reason?: string): void;
-    /** Forcefully destroy the connection without a close frame. */
-    destroy(): void;
-    /** Whether the connection is still open. */
-    get isOpen(): boolean;
-    private writeRaw;
-    private handleData;
-    private handleFrame;
-}
-
-/**
- * Bridges NativeUIBridgeRegistry events to WebSocket clients.
- *
- * Subscribes to all registry event types and broadcasts them as
- * JsonRpcEvent messages to connected WebSocket clients based on
- * their per-connection subscription sets.
- */
-
-/** Options for the WebSocketEventBridge constructor. */
-interface WebSocketEventBridgeOptions {
-    /** Heartbeat ping interval in ms (default 30000) */
-    heartbeatIntervalMs?: number;
-    /** Max number of events to retain in the replay history buffer (default 100, 0 disables) */
-    maxHistory?: number;
-}
-declare class WebSocketEventBridge {
-    private connections;
-    private throttles;
-    private unsubscribers;
-    private heartbeatTimer;
-    private registry;
-    private heartbeatIntervalMs;
-    /**
-     * True ring buffer for event replay history.
-     *
-     * `historyBuf` is a fixed-capacity slot array; `historyHead` points at the
-     * NEXT write position; `historyCount` is the number of valid slots
-     * (clamped to capacity). Append is O(1) — no array shifting.
-     */
-    private historyBuf;
-    private historyHead;
-    private historyCount;
-    constructor(registry: NativeUIBridgeRegistry, optionsOrHeartbeatMs?: WebSocketEventBridgeOptions | number);
-    /** Effective ring buffer capacity. 0 means history is disabled. */
-    private get historyCapacity();
-    /**
-     * Start listening to registry events and broadcasting to WS clients.
-     * Also starts the heartbeat timer.
-     */
-    start(): void;
-    /** Stop listening to registry events and clear connections. */
-    stop(): void;
-    /** Register a new WebSocket connection. */
-    addConnection(conn: WebSocketConnection): void;
-    /** Remove a WebSocket connection (called on disconnect). */
-    removeConnection(connId: string): void;
-    /** Get the number of active connections. */
-    get connectionCount(): number;
-    /**
-     * Add event subscriptions for a connection.
-     *
-     * Event names are stored as glob patterns. Supported forms:
-     *   - Exact:  "element:registered"
-     *   - Prefix: "element:*"
-     *   - Suffix: "*:stateChanged"
-     *   - All:    "*"
-     *
-     * @param throttleMs — if >0, batch rapid events within this window before sending
-     */
-    handleSubscribe(connId: string, events: string[], throttleMs?: number): boolean;
-    /**
-     * Remove event subscriptions for a connection.
-     * If all subscriptions are cleared, also drops the throttle entry
-     * (and any pending flush timer) so a subsequent resubscribe starts clean.
-     */
-    handleUnsubscribe(connId: string, events: string[]): boolean;
-    /**
-     * Get the subscription set for a connection.
-     * Returns the original pattern strings (not compiled regexes).
-     */
-    getSubscriptions(connId: string): string[];
-    /**
-     * Check if a connection is subscribed to a specific event.
-     * Matches exact names first (fast path), then tests each stored
-     * pattern as a glob against the event type.
-     */
-    isSubscribed(connId: string, eventType: string): boolean;
-    /** Get the throttle window (in ms) configured for a connection, or undefined if none. */
-    getThrottleMs(connId: string): number | undefined;
-    /**
-     * Get recent events from the replay history buffer.
-     *
-     * @param filter.events — optional list of glob patterns to match event types against
-     * @param filter.since — optional timestamp (ms); only events at or after this time
-     */
-    getHistory(filter?: {
-        events?: string[];
-        since?: number;
-    }): JsonRpcEvent[];
-    /**
-     * Configure the max history buffer size at runtime. 0 disables history.
-     * Reallocates the ring buffer, preserving the most recent
-     * min(historyCount, newCapacity) events in chronological order.
-     */
-    setMaxHistory(maxHistory: number): void;
-    private broadcastEvent;
-    /** Queue an event for throttled delivery, flushing after the throttle window. */
-    private enqueueThrottled;
-    private startHeartbeat;
-}
-
-/**
- * UI Bridge Native HTTP Server
- *
- * Abstract HTTP server implementation for React Native.
- * This provides a framework-agnostic server interface that can be
- * implemented using various React Native HTTP server libraries.
- *
- * Supported libraries:
- * - react-native-http-bridge (recommended)
- * - @aspect/react-native-http-server
- * - Custom implementations
- */
-
-/**
- * HTTP Request interface (library-agnostic)
- */
-interface HTTPRequest {
-    method: string;
-    path: string;
-    headers: Record<string, string>;
-    query: Record<string, string>;
-    body?: unknown;
-}
-/**
- * HTTP Response interface (library-agnostic)
- */
-interface HTTPResponse {
-    status: number;
-    headers: Record<string, string>;
-    body: string;
-}
-/**
- * Request handler type
- */
-type RequestHandler = (request: HTTPRequest) => Promise<HTTPResponse>;
-/**
- * Server adapter interface
- *
- * Implement this interface to integrate with your chosen HTTP server library.
- */
-interface ServerAdapter {
-    /** Start the server */
-    start(port: number, handler: RequestHandler): Promise<void>;
-    /** Stop the server */
-    stop(): Promise<void>;
-    /** Check if server is running */
-    isRunning(): boolean;
-}
-/**
- * WebSocket-aware server adapter interface.
- *
- * Extends ServerAdapter with callbacks for WebSocket connections.
- * The adapter manages the raw TCP/WS layer; these callbacks let the
- * UI Bridge server handle message routing and event broadcasting.
- */
-interface WebSocketServerAdapter extends ServerAdapter {
-    /** Called when a JSON text frame is received from a WS client. Returns response string or null. */
-    onWebSocketMessage?: (connId: string, message: string) => Promise<string | null>;
-    /** Called when a new WS connection is established after the HTTP 101 upgrade. */
-    onWebSocketConnect?: (connId: string) => void;
-    /** Called when a WS connection is closed or drops. */
-    onWebSocketDisconnect?: (connId: string) => void;
-    /** Send a message to a specific WS connection by ID. */
-    sendToConnection?: (connId: string, message: string) => void;
-    /** Send a message to all connected WS clients. */
-    broadcast?: (message: string) => void;
-}
-/**
- * Native UI Bridge HTTP Server
- */
-declare class NativeUIBridgeServer {
-    private registry;
-    private executor;
-    private config;
-    private handlers;
-    private adapter?;
-    private running;
-    /**
-     * Per-connection cleanup thunks for in-flight waiters (waitForElement,
-     * waitForCondition, ...). Aborted when a client disconnects so the
-     * underlying timers/listeners don't leak.
-     */
-    private pendingWaiters;
-    /**
-     * Observability ring buffers backing `/control/console-errors` and
-     * `/sdk/network-requests`. Allocated unconditionally so the handler can
-     * always read them, but the global patches (`install()`) only fire on
-     * `start()` when `testHooks` is set — production builds don't monkey-patch.
-     */
-    private consoleErrorBuffer;
-    private networkRequestBuffer;
-    constructor(registry: NativeUIBridgeRegistry, executor: NativeActionExecutor, config?: NativeServerConfig);
-    /**
-     * Set the server adapter
-     */
-    setAdapter(adapter: ServerAdapter): void;
-    /**
-     * Set a navigation provider for programmatic route navigation.
-     * This enables `control/page/navigate` and `control/page/back` on native.
-     */
-    setNavigationProvider(provider: NavigationProvider): void;
-    /**
-     * Set a route provider for reporting the current navigation route.
-     * When set, `control/snapshot` responses include `currentRoute` and `segments`.
-     *
-     * Also forwards the provider into the registry so the *default*
-     * `getSnapshot` handler (and any other call site of
-     * `registry.createSnapshot`) reads the route too — without this the
-     * cloud-relay/bare-server path returned `currentRoute: null` even when
-     * a `RouteTracker` was wired, because that path never installed the
-     * server-level handler override below.
-     */
-    setRouteProvider(provider: RouteProvider): void;
-    /**
-     * Set a screenshot provider for native screen capture.
-     * This enables `control/screenshot` on native.
-     */
-    setScreenshotProvider(provider: ScreenshotProvider): void;
-    /**
-     * Start the HTTP server
-     */
-    start(): Promise<void>;
-    /**
-     * Stop the HTTP server
-     */
-    stop(): Promise<void>;
-    /**
-     * Check if server is running
-     */
-    isRunning(): boolean;
-    private eventBridge?;
-    /**
-     * Set the event bridge for WebSocket event broadcasting and subscriptions.
-     */
-    setEventBridge(bridge: WebSocketEventBridge): void;
-    /**
-     * Handle a JSON-RPC message from a WebSocket client.
-     * Parses the message, routes to the appropriate handler, and returns
-     * a JSON string response (or null for events that need no response).
-     */
-    handleWebSocketMessage(connId: string, rawMessage: string): Promise<string | null>;
-    /**
-     * Execute a batch of JSON-RPC requests concurrently.
-     */
-    handleBatchRequest(batch: JsonRpcRequest[]): Promise<JsonRpcResponse[]>;
-    /**
-     * Register an in-flight waiter's cleanup thunk under the given connection.
-     * Returns an `unregister` thunk that the natural-resolution path should
-     * call so the cleanup isn't re-invoked on disconnect.
-     */
-    private registerWaiter;
-    /**
-     * Abort all pending waiters associated with a connection. Called by the
-     * provider's WS disconnect handler so timers/listeners don't leak after
-     * the client goes away.
-     */
-    abortWaitersForConnection(connId: string): void;
-    /**
-     * Wait for an element to be registered, or resolve immediately if it already exists.
-     * Returns a JsonRpcResponse JSON string.
-     */
-    private handleWaitForElement;
-    /**
-     * Wait for an arbitrary element-state predicate to become true.
-     *
-     * Supported `condition` shapes:
-     *   {field: "mounted"|"visible"|"enabled"|"focused", equals: boolean}
-     *   {field: "layout", exists: true}
-     *   {field: string, equals: unknown}  // generic: state[field] === equals
-     *
-     * Resolves immediately with `waited:false` if the predicate already
-     * holds. Otherwise subscribes to `element:registered` and
-     * `element:stateChanged` until the predicate matches or timeout fires.
-     */
-    private handleWaitForCondition;
-    /**
-     * Execute a sequence of JSON-RPC steps in order, stopping on first failure.
-     * Returns a JsonRpcResponse JSON string with per-step results.
-     */
-    private handleSequence;
-    /**
-     * Route a JSON-RPC method string to the appropriate handler using path-style matching.
-     *
-     * Method strings mirror HTTP routes but without the /ui-bridge/ prefix.
-     * Path params are extracted from :name placeholders in the route pattern.
-     *
-     * Examples:
-     *   "health"                                           → handlers.health
-     *   "control/snapshot"                                 → handlers.getSnapshot
-     *   "control/element/tab-runs/action"                  → handlers.executeAction ({id:'tab-runs'})
-     *   "control/component/my-comp/action/submit"          → handlers.executeComponentAction
-     */
-    private routeMethodToHandler;
-    /**
-     * Handle incoming HTTP request
-     *
-     * Exposed as public so that CloudRelayClient can call it directly (without
-     * loopback TCP overhead) when processing tunneled requests.
-     */
-    handleRequest(request: HTTPRequest): Promise<HTTPResponse>;
-    /**
-     * Route an HTTP request to the appropriate handler using WS_ROUTES.
-     *
-     * Strips the `/ui-bridge/` prefix from the path, then iterates the shared
-     * WS_ROUTES table. Each route's `pattern` is matched against the stripped
-     * path via the module-level `parsePath` helper; path params are merged
-     * with the request body into a HandlerContext.
-     *
-     * `httpMethods` disambiguates routes that share a pattern but differ
-     * by verb (e.g. GET vs DELETE on `design/style-guide`). A route without
-     * `httpMethods` is WS-only and will not be matched on HTTP.
-     */
-    private routeRequest;
-}
-/**
- * Create a UI Bridge Native server
- */
-declare function createNativeServer(registry: NativeUIBridgeRegistry, executor: NativeActionExecutor, config?: NativeServerConfig): NativeUIBridgeServer;
-
-export { type APIResponse as A, type NetworkRequestsResponse as B, type ConsoleErrorEntry as C, type DismissModalResponse as D, type PushModalResponse as E, type FillFormFieldInput as F, type TapAtResponse as G, type HTTPRequest as H, isBatchRequest as I, type JsonRpcBatchRequest as J, isSubscribe as K, isUnsubscribe as L, type NativeServerConfig as N, type PushModalRequest as P, type RequestHandler as R, type ScreenshotProvider as S, type TapAtRequest as T, UI_BRIDGE_NATIVE_ROUTES as U, WebSocketConnection as W, type FillFormFieldResult as a, type FillFormRequest as b, type FillFormResponse as c, type HTTPResponse as d, type HandlerContext as e, type HandlerFunction as f, type JsonRpcBatchResponse as g, type JsonRpcEvent as h, type JsonRpcRequest as i, type JsonRpcResponse as j, type NativeServerHandlers as k, NativeUIBridgeServer as l, type NavigationProvider as m, type RouteDefinition as n, type RouteProvider as o, type ServerAdapter as p, WebSocketEventBridge as q, type WebSocketMessageHandler as r, type WebSocketServerAdapter as s, createNativeServer as t, type NetworkRequestEntry as u, type ConsoleErrorsResponse as v, type JsonRpcClientMessage as w, type JsonRpcServerMessage as x, type JsonRpcSubscribe as y, type JsonRpcUnsubscribe as z };