@hypothesi/tauri-mcp-server 0.9.0 → 0.10.0

package/dist/driver/scripts/html2canvas-loader.d.ts

@@ -0,0 +1,25 @@
+/**
+ * html2canvas-pro library loader
+ *
+ * Loads the html2canvas-pro library from node_modules and provides it as a string
+ * that can be injected into the webview. html2canvas-pro is a fork of html2canvas
+ * that adds support for modern CSS color functions like oklch(), oklab(), lab(),
+ * lch(), and color().
+ */
+/** Script ID used for the html2canvas library in the script registry. */
+export declare const HTML2CANVAS_SCRIPT_ID = "__mcp_html2canvas__";
+/**
+ * Get the html2canvas-pro library source code.
+ * Loaded lazily and cached.
+ */
+export declare function getHtml2CanvasSource(): string;
+/**
+ * Build a script that captures a screenshot using html2canvas.
+ * Assumes html2canvas is already loaded (either via script manager or inline).
+ */
+export declare function buildScreenshotCaptureScript(format: 'png' | 'jpeg', quality: number): string;
+/**
+ * Build a script that injects html2canvas and captures a screenshot.
+ * This is the legacy function that inlines the library - kept for fallback.
+ */
+export declare function buildScreenshotScript(format: 'png' | 'jpeg', quality: number): string;

package/dist/driver/scripts/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Script loader for webview injection scripts
+ *
+ * These scripts are loaded at build time and injected into the webview at runtime.
+ * Each script is an IIFE that accepts a params object.
+ */
+export declare const SCRIPTS: {
+    readonly resolveRef: string;
+    readonly interact: string;
+    readonly swipe: string;
+    readonly keyboard: string;
+    readonly waitFor: string;
+    readonly getStyles: string;
+    readonly focus: string;
+    readonly findElement: string;
+    readonly domSnapshot: string;
+    readonly elementPicker: string;
+};
+/** Script ID used for resolve-ref in the script registry. */
+export declare const RESOLVE_REF_SCRIPT_ID = "__mcp_resolve_ref__";
+/**
+ * Get the resolve-ref script source code.
+ */
+export declare function getResolveRefSource(): string;
+/**
+ * Build a script invocation with parameters
+ * The script should be an IIFE that accepts a params object
+ */
+export declare function buildScript(script: string, params: Record<string, unknown>): string;
+/**
+ * Build a script for typing text (uses the keyboard script's typeText function)
+ */
+export declare function buildTypeScript(selector: string, text: string, strategy?: string): string;
+/**
+ * Build a script for key events (press, down, up)
+ */
+export declare function buildKeyEventScript(action: string, key: string, modifiers?: string[]): string;

package/dist/driver/session-manager.d.ts

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import { PluginClient } from './plugin-client.js';
+/**
+ * Session Manager - Native IPC-based session management
+ *
+ * This module provides lightweight native session management using Tauri IPC.
+ * The "session" concept is maintained for API compatibility.
+ *
+ * Connection Strategy:
+ * 1. Try localhost first (most reliable for simulators/emulators/desktop)
+ * 2. If localhost fails and a remote host is configured, try that host
+ * 3. Return error if all connection attempts fail
+ */
+export declare const ManageDriverSessionSchema: z.ZodObject<{
+    action: z.ZodEnum<["start", "stop", "status"]>;
+    host: z.ZodOptional<z.ZodString>;
+    port: z.ZodOptional<z.ZodNumber>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+}, "strip", z.ZodTypeAny, {
+    action: "status" | "start" | "stop";
+    host?: string | undefined;
+    port?: number | undefined;
+    appIdentifier?: string | number | undefined;
+}, {
+    action: "status" | "start" | "stop";
+    host?: string | undefined;
+    port?: number | undefined;
+    appIdentifier?: string | number | undefined;
+}>;
+export interface SessionInfo {
+    name: string;
+    identifier: string | null;
+    host: string;
+    port: number;
+    client: PluginClient;
+    connected: boolean;
+}
+/**
+ * Check if any session is currently active.
+ * @returns true if at least one session exists
+ */
+export declare function hasActiveSession(): boolean;
+/**
+ * Get a specific session by port.
+ */
+export declare function getSession(port: number): SessionInfo | null;
+/**
+ * Get the default session (most recently connected).
+ */
+export declare function getDefaultSession(): SessionInfo | null;
+/**
+ * Get all active sessions.
+ */
+export declare function getAllSessions(): SessionInfo[];
+/**
+ * Resolve target app from port or identifier.
+ * Returns the appropriate session based on the routing logic.
+ */
+export declare function resolveTargetApp(portOrIdentifier?: string | number): SessionInfo;
+/**
+ * Manage session lifecycle (start, stop, or status).
+ *
+ * Connection strategy for 'start':
+ * 1. Try localhost:{port} first (most reliable for simulators/emulators/desktop)
+ * 2. If localhost fails AND a different host is configured, try {host}:{port}
+ * 3. If both fail, try auto-discovery on localhost
+ * 4. Return error if all attempts fail
+ *
+ * @param action - 'start', 'stop', or 'status'
+ * @param host - Optional host address (defaults to env var or localhost)
+ * @param port - Optional port number (defaults to 9223)
+ * @param appIdentifier - Optional app identifier for 'stop' action (port or bundle ID)
+ * @returns For 'start'/'stop': A message string describing the result.
+ *          For 'status': A JSON string with connection details
+ */
+export declare function manageDriverSession(action: 'start' | 'stop' | 'status', host?: string, port?: number, appIdentifier?: string | number): Promise<string>;

package/dist/driver/webview-executor.d.ts

@@ -0,0 +1,122 @@
+import { z } from 'zod';
+/**
+ * Ensures the MCP server is fully initialized and ready to use.
+ * This is called automatically by all tool functions.
+ *
+ * Initialization includes:
+ * - Verifying an active session exists (via driver_session)
+ * - Connecting to the plugin WebSocket using session config
+ * - Console capture is already initialized by bridge.js in the Tauri app
+ *
+ * This function is idempotent - calling it multiple times is safe.
+ *
+ * @throws Error if no session is active (driver_session must be called first)
+ */
+export declare function ensureReady(): Promise<void>;
+/**
+ * Reset initialization state (useful for testing or reconnecting).
+ */
+export declare function resetInitialization(): void;
+export interface ExecuteInWebviewResult {
+    result: string;
+    windowLabel: string;
+    warning?: string;
+}
+/**
+ * Execute JavaScript in the Tauri webview using native IPC via WebSocket.
+ *
+ * @param script - JavaScript code to execute in the webview context
+ * @param windowId - Optional window label to target (defaults to "main")
+ * @param appIdentifier - Optional app identifier to target specific app
+ * @returns Result of the script execution with window context
+ */
+export declare function executeInWebview(script: string, windowId?: string, appIdentifier?: string | number): Promise<string>;
+/**
+ * Execute JavaScript in the Tauri webview and return window context.
+ *
+ * @param script - JavaScript code to execute in the webview context
+ * @param windowId - Optional window label to target (defaults to "main")
+ * @param appIdentifier - Optional app identifier to target specific app
+ * @returns Result of the script execution with window context
+ */
+export declare function executeInWebviewWithContext(script: string, windowId?: string, appIdentifier?: string | number): Promise<ExecuteInWebviewResult>;
+/**
+ * Execute async JavaScript in the webview with timeout support.
+ *
+ * @param script - JavaScript code to execute (can use await)
+ * @param windowId - Optional window label to target (defaults to "main")
+ * @param timeout - Timeout in milliseconds (default: 5000)
+ * @returns Result of the script execution
+ */
+export declare function executeAsyncInWebview(script: string, windowId?: string, timeout?: number): Promise<string>;
+/**
+ * Initialize console log capture in the webview.
+ * This intercepts console methods and stores logs in memory.
+ *
+ * NOTE: Console capture is now automatically initialized by bridge.js when the
+ * Tauri app starts. This function is kept for backwards compatibility and will
+ * simply return early if capture is already initialized.
+ */
+export declare function initializeConsoleCapture(): Promise<string>;
+/**
+ * Retrieve captured console logs with optional filtering.
+ *
+ * @param filter - Optional regex pattern to filter log messages
+ * @param since - Optional ISO timestamp to filter logs after this time
+ * @param windowId - Optional window label to target (defaults to "main")
+ * @param appIdentifier - Optional app identifier to target specific app
+ * @returns Formatted console logs as string
+ */
+export declare function getConsoleLogs(filter?: string, since?: string, windowId?: string, appIdentifier?: string | number): Promise<string>;
+/**
+ * Clear all captured console logs.
+ */
+export declare function clearConsoleLogs(): Promise<string>;
+import type { ToolContent } from '../tools-registry.js';
+/**
+ * Result of a screenshot capture, containing both image data and optional context.
+ */
+export interface ScreenshotResult {
+    content: ToolContent[];
+}
+export interface CaptureScreenshotOptions {
+    format?: 'png' | 'jpeg';
+    quality?: number;
+    windowId?: string;
+    appIdentifier?: string | number;
+    maxWidth?: number;
+}
+/**
+ * Capture a screenshot of the entire webview.
+ *
+ * @param options - Screenshot options (format, quality, windowId, appIdentifier, etc.)
+ * @returns Screenshot result with image content
+ */
+export declare function captureScreenshot(options?: CaptureScreenshotOptions): Promise<ScreenshotResult>;
+export declare const ExecuteScriptSchema: z.ZodObject<{
+    script: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    script: string;
+}, {
+    script: string;
+}>;
+export declare const GetConsoleLogsSchema: z.ZodObject<{
+    filter: z.ZodOptional<z.ZodString>;
+    since: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    filter?: string | undefined;
+    since?: string | undefined;
+}, {
+    filter?: string | undefined;
+    since?: string | undefined;
+}>;
+export declare const CaptureScreenshotSchema: z.ZodObject<{
+    format: z.ZodDefault<z.ZodOptional<z.ZodEnum<["png", "jpeg"]>>>;
+    quality: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    format: "png" | "jpeg";
+    quality?: number | undefined;
+}, {
+    format?: "png" | "jpeg" | undefined;
+    quality?: number | undefined;
+}>;

package/dist/driver/webview-interactions.d.ts

@@ -0,0 +1,349 @@
+import { z } from 'zod';
+import { ScreenshotResult } from './webview-executor.js';
+/**
+ * Base schema mixin for tools that can target a specific window and app.
+ * All webview tools extend this to support multi-window and multi-app scenarios.
+ */
+export declare const WindowTargetSchema: z.ZodObject<{
+    windowId: z.ZodOptional<z.ZodString>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+}, "strip", z.ZodTypeAny, {
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+}, {
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+}>;
+export declare const InteractSchema: z.ZodObject<{
+    windowId: z.ZodOptional<z.ZodString>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+} & {
+    action: z.ZodEnum<["click", "double-click", "long-press", "scroll", "swipe", "focus"]>;
+    selector: z.ZodOptional<z.ZodString>;
+    strategy: z.ZodDefault<z.ZodEnum<["css", "xpath", "text"]>>;
+    x: z.ZodOptional<z.ZodNumber>;
+    y: z.ZodOptional<z.ZodNumber>;
+    duration: z.ZodOptional<z.ZodNumber>;
+    scrollX: z.ZodOptional<z.ZodNumber>;
+    scrollY: z.ZodOptional<z.ZodNumber>;
+    fromX: z.ZodOptional<z.ZodNumber>;
+    fromY: z.ZodOptional<z.ZodNumber>;
+    toX: z.ZodOptional<z.ZodNumber>;
+    toY: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    action: "swipe" | "focus" | "click" | "double-click" | "long-press" | "scroll";
+    strategy: "css" | "text" | "xpath";
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    selector?: string | undefined;
+    x?: number | undefined;
+    y?: number | undefined;
+    duration?: number | undefined;
+    scrollX?: number | undefined;
+    scrollY?: number | undefined;
+    fromX?: number | undefined;
+    fromY?: number | undefined;
+    toX?: number | undefined;
+    toY?: number | undefined;
+}, {
+    action: "swipe" | "focus" | "click" | "double-click" | "long-press" | "scroll";
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    selector?: string | undefined;
+    strategy?: "css" | "text" | "xpath" | undefined;
+    x?: number | undefined;
+    y?: number | undefined;
+    duration?: number | undefined;
+    scrollX?: number | undefined;
+    scrollY?: number | undefined;
+    fromX?: number | undefined;
+    fromY?: number | undefined;
+    toX?: number | undefined;
+    toY?: number | undefined;
+}>;
+export declare const ScreenshotSchema: z.ZodObject<{
+    windowId: z.ZodOptional<z.ZodString>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+} & {
+    format: z.ZodDefault<z.ZodOptional<z.ZodEnum<["png", "jpeg"]>>>;
+    quality: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    filePath: z.ZodOptional<z.ZodString>;
+    maxWidth: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    format: "png" | "jpeg";
+    quality: number;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    maxWidth?: number | undefined;
+    filePath?: string | undefined;
+}, {
+    format?: "png" | "jpeg" | undefined;
+    quality?: number | undefined;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    maxWidth?: number | undefined;
+    filePath?: string | undefined;
+}>;
+export declare const KeyboardSchema: z.ZodObject<{
+    windowId: z.ZodOptional<z.ZodString>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+} & {
+    action: z.ZodEnum<["type", "press", "down", "up"]>;
+    selector: z.ZodOptional<z.ZodString>;
+    strategy: z.ZodDefault<z.ZodEnum<["css", "xpath", "text"]>>;
+    text: z.ZodOptional<z.ZodString>;
+    key: z.ZodOptional<z.ZodString>;
+    modifiers: z.ZodOptional<z.ZodArray<z.ZodEnum<["Control", "Alt", "Shift", "Meta"]>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    action: "type" | "press" | "down" | "up";
+    strategy: "css" | "text" | "xpath";
+    text?: string | undefined;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    selector?: string | undefined;
+    key?: string | undefined;
+    modifiers?: ("Control" | "Alt" | "Shift" | "Meta")[] | undefined;
+}, {
+    action: "type" | "press" | "down" | "up";
+    text?: string | undefined;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    selector?: string | undefined;
+    strategy?: "css" | "text" | "xpath" | undefined;
+    key?: string | undefined;
+    modifiers?: ("Control" | "Alt" | "Shift" | "Meta")[] | undefined;
+}>;
+export declare const WaitForSchema: z.ZodObject<{
+    windowId: z.ZodOptional<z.ZodString>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+} & {
+    type: z.ZodEnum<["selector", "text", "ipc-event"]>;
+    value: z.ZodString;
+    strategy: z.ZodDefault<z.ZodEnum<["css", "xpath", "text"]>>;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    type: "text" | "selector" | "ipc-event";
+    strategy: "css" | "text" | "xpath";
+    timeout: number;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+}, {
+    value: string;
+    type: "text" | "selector" | "ipc-event";
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    strategy?: "css" | "text" | "xpath" | undefined;
+    timeout?: number | undefined;
+}>;
+export declare const GetStylesSchema: z.ZodObject<{
+    windowId: z.ZodOptional<z.ZodString>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+} & {
+    selector: z.ZodString;
+    strategy: z.ZodDefault<z.ZodEnum<["css", "xpath", "text"]>>;
+    properties: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    multiple: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    selector: string;
+    strategy: "css" | "text" | "xpath";
+    multiple: boolean;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    properties?: string[] | undefined;
+}, {
+    selector: string;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    strategy?: "css" | "text" | "xpath" | undefined;
+    properties?: string[] | undefined;
+    multiple?: boolean | undefined;
+}>;
+export declare const ExecuteJavaScriptSchema: z.ZodObject<{
+    windowId: z.ZodOptional<z.ZodString>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+} & {
+    script: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodUnknown, "many">>;
+}, "strip", z.ZodTypeAny, {
+    script: string;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    args?: unknown[] | undefined;
+}, {
+    script: string;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    args?: unknown[] | undefined;
+}>;
+export declare const FocusElementSchema: z.ZodObject<{
+    windowId: z.ZodOptional<z.ZodString>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+} & {
+    selector: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    selector: string;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+}, {
+    selector: string;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+}>;
+export declare const FindElementSchema: z.ZodObject<{
+    windowId: z.ZodOptional<z.ZodString>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+} & {
+    selector: z.ZodString;
+    strategy: z.ZodDefault<z.ZodEnum<["css", "xpath", "text"]>>;
+}, "strip", z.ZodTypeAny, {
+    selector: string;
+    strategy: "css" | "text" | "xpath";
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+}, {
+    selector: string;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    strategy?: "css" | "text" | "xpath" | undefined;
+}>;
+export declare const GetConsoleLogsSchema: z.ZodObject<{
+    windowId: z.ZodOptional<z.ZodString>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+} & {
+    filter: z.ZodOptional<z.ZodString>;
+    since: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    filter?: string | undefined;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    since?: string | undefined;
+}, {
+    filter?: string | undefined;
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    since?: string | undefined;
+}>;
+export declare const DomSnapshotSchema: z.ZodObject<{
+    windowId: z.ZodOptional<z.ZodString>;
+    appIdentifier: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+} & {
+    type: z.ZodEnum<["accessibility", "structure"]>;
+    selector: z.ZodOptional<z.ZodString>;
+    strategy: z.ZodDefault<z.ZodEnum<["css", "xpath", "text"]>>;
+}, "strip", z.ZodTypeAny, {
+    type: "accessibility" | "structure";
+    strategy: "css" | "text" | "xpath";
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    selector?: string | undefined;
+}, {
+    type: "accessibility" | "structure";
+    windowId?: string | undefined;
+    appIdentifier?: string | number | undefined;
+    selector?: string | undefined;
+    strategy?: "css" | "text" | "xpath" | undefined;
+}>;
+export declare function interact(options: {
+    action: string;
+    selector?: string;
+    strategy?: string;
+    x?: number;
+    y?: number;
+    duration?: number;
+    scrollX?: number;
+    scrollY?: number;
+    fromX?: number;
+    fromY?: number;
+    toX?: number;
+    toY?: number;
+    windowId?: string;
+    appIdentifier?: string | number;
+}): Promise<string>;
+export interface ScreenshotOptions {
+    quality?: number;
+    format?: 'png' | 'jpeg';
+    windowId?: string;
+    filePath?: string;
+    appIdentifier?: string | number;
+    maxWidth?: number;
+}
+export interface ScreenshotFileResult {
+    filePath: string;
+    format: 'png' | 'jpeg';
+}
+export declare function screenshot(options?: ScreenshotOptions): Promise<ScreenshotResult | ScreenshotFileResult>;
+export interface KeyboardOptions {
+    action: string;
+    selectorOrKey?: string;
+    strategy?: string;
+    textOrModifiers?: string | string[];
+    modifiers?: string[];
+    windowId?: string;
+    appIdentifier?: string | number;
+}
+export declare function keyboard(options: KeyboardOptions): Promise<string>;
+export interface WaitForOptions {
+    type: string;
+    value: string;
+    strategy?: string;
+    timeout?: number;
+    windowId?: string;
+    appIdentifier?: string | number;
+}
+export declare function waitFor(options: WaitForOptions): Promise<string>;
+export interface GetStylesOptions {
+    selector: string;
+    strategy?: string;
+    properties?: string[];
+    multiple?: boolean;
+    windowId?: string;
+    appIdentifier?: string | number;
+}
+export declare function getStyles(options: GetStylesOptions): Promise<string>;
+export interface ExecuteJavaScriptOptions {
+    script: string;
+    args?: unknown[];
+    windowId?: string;
+    appIdentifier?: string | number;
+}
+export declare function executeJavaScript(options: ExecuteJavaScriptOptions): Promise<string>;
+export interface FocusElementOptions {
+    selector: string;
+    strategy?: string;
+    windowId?: string;
+    appIdentifier?: string | number;
+}
+export declare function focusElement(options: FocusElementOptions): Promise<string>;
+export interface FindElementOptions {
+    selector: string;
+    strategy: string;
+    windowId?: string;
+    appIdentifier?: string | number;
+}
+/**
+ * Find an element using various selector strategies.
+ */
+export declare function findElement(options: FindElementOptions): Promise<string>;
+export interface GetConsoleLogsOptions {
+    filter?: string;
+    since?: string;
+    windowId?: string;
+    appIdentifier?: string | number;
+}
+/**
+ * Get console logs from the webview.
+ */
+export declare function getConsoleLogs(options?: GetConsoleLogsOptions): Promise<string>;
+export interface DomSnapshotOptions {
+    type: 'accessibility' | 'structure';
+    selector?: string;
+    strategy?: string;
+    windowId?: string;
+    appIdentifier?: string | number;
+}
+/**
+ * Generate a structured DOM snapshot for AI consumption.
+ * Uses aria-api for comprehensive, spec-compliant accessibility computation.
+ */
+export declare function domSnapshot(options: DomSnapshotOptions): Promise<string>;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};