@phyto/driver-tauri 0.1.5

package/dist/index.d.ts

@@ -0,0 +1,167 @@
+/**
+ * Union of supported locator strategies. The same shapes the harness
+ * accepts on the wire — duplicated here so users of the driver don't
+ * have to depend on the `phyto` package.
+ *
+ * - `css`: standard CSS selector (the most flexible — also produced
+ *   when a plain string is passed to any driver method).
+ * - `role`: ARIA role with optional accessible name (exact match on
+ *   `textContent` or `aria-label`/`aria-labelledby`).
+ * - `text`: any element whose textContent includes the given string.
+ * - `testId`: shorthand for `[data-testid="..."]`.
+ * - `component`: framework-aware lookup (currently React only).
+ */
+type Locator = {
+    css: string;
+} | {
+    role: string;
+    name?: string;
+} | {
+    text: string;
+} | {
+    testId: string;
+} | {
+    component: string;
+    props?: Record<string, unknown>;
+};
+/** Argument shape accepted by element-targeting driver methods. */
+type LocatorInput = string | Locator;
+interface TauriDriverOptions {
+    /** Path to the built Tauri binary */
+    binary: string;
+    /** Port for the automation server (default: 9876) */
+    port?: number;
+    /** Timeout in ms for waitUntilReady polling (default: 30000) */
+    readyTimeout?: number;
+    /** Poll interval in ms for waitUntilReady (default: 250) */
+    readyInterval?: number;
+    /** Additional environment variables for the app process */
+    env?: Record<string, string>;
+    /** Default timeout in ms for all wait operations (default: 5000) */
+    defaultTimeout?: number;
+}
+/** Transport-level response wrapper from the Tauri automation server. */
+interface TransportResult<T = unknown> {
+    ok: boolean;
+    value?: T;
+    error?: string;
+}
+interface WaitOptions {
+    /** Timeout in ms (default: driver's defaultTimeout) */
+    timeout?: number;
+    /** Poll interval in ms (default: 100) */
+    interval?: number;
+}
+interface InteractionOptions extends WaitOptions {
+    /** If true, also wait for the element to not be disabled (default: false) */
+    enabled?: boolean;
+}
+declare class TauriDriver {
+    private process;
+    private readonly binary;
+    private readonly port;
+    private readonly readyTimeout;
+    private readonly readyInterval;
+    private readonly env;
+    private readonly baseUrl;
+    private readonly defaultTimeout;
+    constructor(options: TauriDriverOptions);
+    /**
+     * Launch the Tauri app and wait until the automation server is ready.
+     */
+    launch(): Promise<void>;
+    /**
+     * Poll the /health endpoint until the automation server is responsive,
+     * then verify wire-protocol compatibility via /info.
+     *
+     * Fails fast (without retry) on a version mismatch — re-polling won't
+     * fix a stale plugin binary.
+     */
+    waitUntilReady(): Promise<void>;
+    /**
+     * Fetch plugin metadata (wire protocol + plugin version) from /info.
+     * Used by `waitUntilReady` to assert the plugin's protocol version
+     * matches this driver's `PROTOCOL_VERSION`.
+     */
+    fetchInfo(): Promise<{
+        protocol_version: number;
+        plugin_version: string;
+        plugin: string;
+    }>;
+    /**
+     * Verify the running plugin's wire protocol matches this driver's.
+     * Throws a clear error on mismatch — both versions named so the user
+     * knows which side is stale.
+     */
+    private assertPluginCompatible;
+    /**
+     * Shut down the app process.
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Evaluate arbitrary JavaScript in the webview and return the result.
+     * This is an escape hatch for operations not covered by the command
+     * protocol (e.g. custom app-specific scripts).
+     */
+    evaluate<T = unknown>(script: string): Promise<T>;
+    /**
+     * Send a declarative command to the in-page harness via POST /command.
+     * Returns the structured result from the harness.
+     *
+     * Throws if the harness returns `{ ok: false }`.
+     */
+    command<T = unknown>(payload: Record<string, unknown>): Promise<T>;
+    /**
+     * Perform the protocol version handshake with the in-page harness.
+     * Returns true if the harness is available and compatible.
+     */
+    handshake(): Promise<void>;
+    /**
+     * Click an element matching the given target. Accepts a CSS selector
+     * string or any `Locator` object (e.g. `{ role: "button", name: "Next" }`
+     * for text-based button matching, or `{ testId: "..." }`).
+     * Auto-waits for the element to be visible before clicking.
+     * With `{ enabled: true }`, also waits for `!el.disabled` — useful for
+     * buttons gated by form validation.
+     */
+    click(target: LocatorInput, options?: InteractionOptions): Promise<void>;
+    /**
+     * Type text into an input/textarea matching the given target.
+     * Auto-waits for the element to be visible before typing.
+     * Finds the actual `<input>` or `<textarea>` element (even inside wrapper
+     * components — useful for Mantine, which puts `data-testid` on the
+     * wrapper `<div>`), sets the value using the React-compatible native
+     * setter, and dispatches input/change events so React's synthetic
+     * event system fires onChange handlers.
+     */
+    type(target: LocatorInput, text: string, options?: InteractionOptions): Promise<void>;
+    /**
+     * Get the text content of an element matching the given target.
+     * Auto-waits for the element to be visible before reading.
+     */
+    textContent(target: LocatorInput, options?: InteractionOptions): Promise<string>;
+    /**
+     * Wait until an element matching the target is in the DOM and visible.
+     */
+    waitFor(target: LocatorInput, options?: WaitOptions): Promise<void>;
+    /**
+     * Wait until an element matching the target contains the specified text.
+     */
+    waitForText(target: LocatorInput, text: string, options?: WaitOptions): Promise<void>;
+    /**
+     * Wait until any of the given targets matches a visible element.
+     * Returns the target that matched, so the caller can branch.
+     */
+    waitForAny<T extends LocatorInput>(targets: T[], options?: WaitOptions): Promise<T>;
+    /**
+     * Wait until an element is no longer in the DOM.
+     */
+    waitForGone(target: LocatorInput, options?: WaitOptions): Promise<void>;
+    /**
+     * Invoke a Tauri command from the webview.
+     * Calls the Tauri backend directly via window.__TAURI_INTERNALS__.invoke().
+     */
+    invoke<T = unknown>(command: string, args?: Record<string, unknown>): Promise<T>;
+}
+
+export { type InteractionOptions, type Locator, type LocatorInput, TauriDriver, type TauriDriverOptions, type TransportResult, type WaitOptions };

package/dist/index.js

@@ -0,0 +1,287 @@
+// src/index.ts
+import { spawn } from "child_process";
+var PROTOCOL_VERSION = 1;
+function toLocator(input) {
+  return typeof input === "string" ? { css: input } : input;
+}
+var TauriDriver = class {
+  process = null;
+  binary;
+  port;
+  readyTimeout;
+  readyInterval;
+  env;
+  baseUrl;
+  defaultTimeout;
+  constructor(options) {
+    this.binary = options.binary;
+    this.port = options.port ?? 9876;
+    this.readyTimeout = options.readyTimeout ?? 12e4;
+    this.readyInterval = options.readyInterval ?? 250;
+    this.env = options.env ?? {};
+    this.baseUrl = `http://localhost:${this.port}`;
+    this.defaultTimeout = options.defaultTimeout ?? 5e3;
+  }
+  /**
+   * Launch the Tauri app and wait until the automation server is ready.
+   */
+  async launch() {
+    this.process = spawn(this.binary, [], {
+      stdio: "pipe",
+      env: { ...process.env, ...this.env }
+    });
+    this.process.stderr?.on("data", (data) => {
+      const line = data.toString().trim();
+      if (line) {
+        process.stderr.write(`[app] ${line}
+`);
+      }
+    });
+    this.process.on("error", (err) => {
+      throw new Error(`Failed to launch app binary: ${err.message}`);
+    });
+    await this.waitUntilReady();
+  }
+  /**
+   * Poll the /health endpoint until the automation server is responsive,
+   * then verify wire-protocol compatibility via /info.
+   *
+   * Fails fast (without retry) on a version mismatch — re-polling won't
+   * fix a stale plugin binary.
+   */
+  async waitUntilReady() {
+    const deadline = Date.now() + this.readyTimeout;
+    while (Date.now() < deadline) {
+      try {
+        const res = await fetch(`${this.baseUrl}/health`, {
+          signal: AbortSignal.timeout(2e3)
+        });
+        if (res.ok) {
+          await this.assertPluginCompatible();
+          return;
+        }
+      } catch {
+      }
+      await sleep(this.readyInterval);
+    }
+    throw new Error(
+      `Automation server did not become ready within ${this.readyTimeout}ms`
+    );
+  }
+  /**
+   * Fetch plugin metadata (wire protocol + plugin version) from /info.
+   * Used by `waitUntilReady` to assert the plugin's protocol version
+   * matches this driver's `PROTOCOL_VERSION`.
+   */
+  async fetchInfo() {
+    const res = await fetch(`${this.baseUrl}/info`, {
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (!res.ok) {
+      throw new Error(
+        `GET /info failed with status ${res.status}. Is tauri-plugin-phyto installed and registered?`
+      );
+    }
+    return await res.json();
+  }
+  /**
+   * Verify the running plugin's wire protocol matches this driver's.
+   * Throws a clear error on mismatch — both versions named so the user
+   * knows which side is stale.
+   */
+  async assertPluginCompatible() {
+    const info = await this.fetchInfo();
+    if (info.protocol_version !== PROTOCOL_VERSION) {
+      throw new Error(
+        `Phyto protocol version mismatch:
+  - @phyto/driver-tauri:        wire protocol v${PROTOCOL_VERSION}
+  - tauri-plugin-phyto (v${info.plugin_version}): wire protocol v${info.protocol_version}
+
+Re-build the Tauri app against a matching version of tauri-plugin-phyto, or update the npm packages to match the plugin.`
+      );
+    }
+  }
+  /**
+   * Shut down the app process.
+   */
+  async shutdown() {
+    if (this.process) {
+      this.process.kill("SIGTERM");
+      await Promise.race([
+        new Promise((resolve) => {
+          this.process?.on("exit", () => resolve());
+        }),
+        sleep(5e3).then(() => {
+          this.process?.kill("SIGKILL");
+        })
+      ]);
+      this.process = null;
+    }
+  }
+  /**
+   * Evaluate arbitrary JavaScript in the webview and return the result.
+   * This is an escape hatch for operations not covered by the command
+   * protocol (e.g. custom app-specific scripts).
+   */
+  async evaluate(script) {
+    return this.command({
+      action: "eval",
+      script
+    });
+  }
+  /**
+   * Send a declarative command to the in-page harness via POST /command.
+   * Returns the structured result from the harness.
+   *
+   * Throws if the harness returns `{ ok: false }`.
+   */
+  async command(payload) {
+    const res = await fetch(`${this.baseUrl}/command`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload)
+    });
+    const result = await res.json();
+    if (!result.ok) {
+      throw new Error(result.error ?? "Command transport failed");
+    }
+    const commandResult = result.value;
+    if (!commandResult || !commandResult.ok) {
+      throw new Error(
+        commandResult?.error ?? "Command failed with unknown error"
+      );
+    }
+    return commandResult.value;
+  }
+  /**
+   * Perform the protocol version handshake with the in-page harness.
+   * Returns true if the harness is available and compatible.
+   */
+  async handshake() {
+    await this.command({
+      action: "handshake",
+      protocolVersion: PROTOCOL_VERSION
+    });
+  }
+  // ─── Public API ─────────────────────────────────────────────────
+  /**
+   * Click an element matching the given target. Accepts a CSS selector
+   * string or any `Locator` object (e.g. `{ role: "button", name: "Next" }`
+   * for text-based button matching, or `{ testId: "..." }`).
+   * Auto-waits for the element to be visible before clicking.
+   * With `{ enabled: true }`, also waits for `!el.disabled` — useful for
+   * buttons gated by form validation.
+   */
+  async click(target, options) {
+    await this.command({
+      action: "click",
+      locator: toLocator(target),
+      options: {
+        timeout: options?.timeout ?? this.defaultTimeout,
+        enabled: options?.enabled
+      }
+    });
+  }
+  /**
+   * Type text into an input/textarea matching the given target.
+   * Auto-waits for the element to be visible before typing.
+   * Finds the actual `<input>` or `<textarea>` element (even inside wrapper
+   * components — useful for Mantine, which puts `data-testid` on the
+   * wrapper `<div>`), sets the value using the React-compatible native
+   * setter, and dispatches input/change events so React's synthetic
+   * event system fires onChange handlers.
+   */
+  async type(target, text, options) {
+    await this.command({
+      action: "type",
+      locator: toLocator(target),
+      text,
+      options: {
+        timeout: options?.timeout ?? this.defaultTimeout
+      }
+    });
+  }
+  /**
+   * Get the text content of an element matching the given target.
+   * Auto-waits for the element to be visible before reading.
+   */
+  async textContent(target, options) {
+    return this.command({
+      action: "text-content",
+      locator: toLocator(target),
+      options: {
+        timeout: options?.timeout ?? this.defaultTimeout
+      }
+    });
+  }
+  /**
+   * Wait until an element matching the target is in the DOM and visible.
+   */
+  async waitFor(target, options) {
+    await this.command({
+      action: "wait-for",
+      locator: toLocator(target),
+      options: {
+        timeout: options?.timeout ?? this.defaultTimeout
+      }
+    });
+  }
+  /**
+   * Wait until an element matching the target contains the specified text.
+   */
+  async waitForText(target, text, options) {
+    await this.command({
+      action: "wait-for-text",
+      locator: toLocator(target),
+      text,
+      options: {
+        timeout: options?.timeout ?? this.defaultTimeout
+      }
+    });
+  }
+  /**
+   * Wait until any of the given targets matches a visible element.
+   * Returns the target that matched, so the caller can branch.
+   */
+  async waitForAny(targets, options) {
+    const locators = targets.map(toLocator);
+    const matchedIndex = await this.command({
+      action: "wait-for-any",
+      locators,
+      options: {
+        timeout: options?.timeout ?? this.defaultTimeout
+      }
+    });
+    return targets[matchedIndex];
+  }
+  /**
+   * Wait until an element is no longer in the DOM.
+   */
+  async waitForGone(target, options) {
+    await this.command({
+      action: "wait-for-gone",
+      locator: toLocator(target),
+      options: {
+        timeout: options?.timeout ?? this.defaultTimeout
+      }
+    });
+  }
+  /**
+   * Invoke a Tauri command from the webview.
+   * Calls the Tauri backend directly via window.__TAURI_INTERNALS__.invoke().
+   */
+  async invoke(command, args) {
+    return this.command({
+      action: "invoke",
+      command,
+      args: args ?? {}
+    });
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export {
+  TauriDriver
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { ChildProcess, spawn } from \"node:child_process\";\n\n/** Protocol version — must match the harness. */\nconst PROTOCOL_VERSION = 1;\n\n// ─── Locator types ──────────────────────────────────────────────────\n\n/**\n * Union of supported locator strategies. The same shapes the harness\n * accepts on the wire — duplicated here so users of the driver don't\n * have to depend on the `phyto` package.\n *\n * - `css`: standard CSS selector (the most flexible — also produced\n *   when a plain string is passed to any driver method).\n * - `role`: ARIA role with optional accessible name (exact match on\n *   `textContent` or `aria-label`/`aria-labelledby`).\n * - `text`: any element whose textContent includes the given string.\n * - `testId`: shorthand for `[data-testid=\"...\"]`.\n * - `component`: framework-aware lookup (currently React only).\n */\nexport type Locator =\n  | { css: string }\n  | { role: string; name?: string }\n  | { text: string }\n  | { testId: string }\n  | { component: string; props?: Record<string, unknown> };\n\n/** Argument shape accepted by element-targeting driver methods. */\nexport type LocatorInput = string | Locator;\n\n/**\n * Normalize a `LocatorInput` to a `Locator`. A bare string is treated\n * as a CSS selector — preserves backward compatibility with the\n * original string-only API.\n */\nfunction toLocator(input: LocatorInput): Locator {\n  return typeof input === \"string\" ? { css: input } : input;\n}\n\n// ─── Types ──────────────────────────────────────────────────────────\n\nexport interface TauriDriverOptions {\n  /** Path to the built Tauri binary */\n  binary: string;\n  /** Port for the automation server (default: 9876) */\n  port?: number;\n  /** Timeout in ms for waitUntilReady polling (default: 30000) */\n  readyTimeout?: number;\n  /** Poll interval in ms for waitUntilReady (default: 250) */\n  readyInterval?: number;\n  /** Additional environment variables for the app process */\n  env?: Record<string, string>;\n  /** Default timeout in ms for all wait operations (default: 5000) */\n  defaultTimeout?: number;\n}\n\n/** Transport-level response wrapper from the Tauri automation server. */\nexport interface TransportResult<T = unknown> {\n  ok: boolean;\n  value?: T;\n  error?: string;\n}\n\nexport interface WaitOptions {\n  /** Timeout in ms (default: driver's defaultTimeout) */\n  timeout?: number;\n  /** Poll interval in ms (default: 100) */\n  interval?: number;\n}\n\nexport interface InteractionOptions extends WaitOptions {\n  /** If true, also wait for the element to not be disabled (default: false) */\n  enabled?: boolean;\n}\n\n// ─── Driver ─────────────────────────────────────────────────────────\n\nexport class TauriDriver {\n  private process: ChildProcess | null = null;\n  private readonly binary: string;\n  private readonly port: number;\n  private readonly readyTimeout: number;\n  private readonly readyInterval: number;\n  private readonly env: Record<string, string>;\n  private readonly baseUrl: string;\n  private readonly defaultTimeout: number;\n\n  constructor(options: TauriDriverOptions) {\n    this.binary = options.binary;\n    this.port = options.port ?? 9876;\n    this.readyTimeout = options.readyTimeout ?? 120_000;\n    this.readyInterval = options.readyInterval ?? 250;\n    this.env = options.env ?? {};\n    this.baseUrl = `http://localhost:${this.port}`;\n    this.defaultTimeout = options.defaultTimeout ?? 5000;\n  }\n\n  /**\n   * Launch the Tauri app and wait until the automation server is ready.\n   */\n  async launch(): Promise<void> {\n    this.process = spawn(this.binary, [], {\n      stdio: \"pipe\",\n      env: { ...process.env, ...this.env },\n    });\n\n    // Forward stderr for debugging\n    this.process.stderr?.on(\"data\", (data: Buffer) => {\n      const line = data.toString().trim();\n      if (line) {\n        process.stderr.write(`[app] ${line}\\n`);\n      }\n    });\n\n    this.process.on(\"error\", (err) => {\n      throw new Error(`Failed to launch app binary: ${err.message}`);\n    });\n\n    await this.waitUntilReady();\n  }\n\n  /**\n   * Poll the /health endpoint until the automation server is responsive,\n   * then verify wire-protocol compatibility via /info.\n   *\n   * Fails fast (without retry) on a version mismatch — re-polling won't\n   * fix a stale plugin binary.\n   */\n  async waitUntilReady(): Promise<void> {\n    const deadline = Date.now() + this.readyTimeout;\n\n    while (Date.now() < deadline) {\n      try {\n        const res = await fetch(`${this.baseUrl}/health`, {\n          signal: AbortSignal.timeout(2000),\n        });\n        if (res.ok) {\n          await this.assertPluginCompatible();\n          return;\n        }\n      } catch {\n        // Server not ready yet — keep polling\n      }\n      await sleep(this.readyInterval);\n    }\n\n    throw new Error(\n      `Automation server did not become ready within ${this.readyTimeout}ms`\n    );\n  }\n\n  /**\n   * Fetch plugin metadata (wire protocol + plugin version) from /info.\n   * Used by `waitUntilReady` to assert the plugin's protocol version\n   * matches this driver's `PROTOCOL_VERSION`.\n   */\n  async fetchInfo(): Promise<{\n    protocol_version: number;\n    plugin_version: string;\n    plugin: string;\n  }> {\n    const res = await fetch(`${this.baseUrl}/info`, {\n      signal: AbortSignal.timeout(2000),\n    });\n    if (!res.ok) {\n      throw new Error(\n        `GET /info failed with status ${res.status}. Is tauri-plugin-phyto installed and registered?`\n      );\n    }\n    return (await res.json()) as {\n      protocol_version: number;\n      plugin_version: string;\n      plugin: string;\n    };\n  }\n\n  /**\n   * Verify the running plugin's wire protocol matches this driver's.\n   * Throws a clear error on mismatch — both versions named so the user\n   * knows which side is stale.\n   */\n  private async assertPluginCompatible(): Promise<void> {\n    const info = await this.fetchInfo();\n    if (info.protocol_version !== PROTOCOL_VERSION) {\n      throw new Error(\n        `Phyto protocol version mismatch:\\n` +\n          `  - @phyto/driver-tauri:        wire protocol v${PROTOCOL_VERSION}\\n` +\n          `  - tauri-plugin-phyto (v${info.plugin_version}): wire protocol v${info.protocol_version}\\n` +\n          `\\n` +\n          `Re-build the Tauri app against a matching version of tauri-plugin-phyto, ` +\n          `or update the npm packages to match the plugin.`\n      );\n    }\n  }\n\n  /**\n   * Shut down the app process.\n   */\n  async shutdown(): Promise<void> {\n    if (this.process) {\n      this.process.kill(\"SIGTERM\");\n\n      // Give it a moment to exit gracefully, then force kill\n      await Promise.race([\n        new Promise<void>((resolve) => {\n          this.process?.on(\"exit\", () => resolve());\n        }),\n        sleep(5000).then(() => {\n          this.process?.kill(\"SIGKILL\");\n        }),\n      ]);\n\n      this.process = null;\n    }\n  }\n\n  /**\n   * Evaluate arbitrary JavaScript in the webview and return the result.\n   * This is an escape hatch for operations not covered by the command\n   * protocol (e.g. custom app-specific scripts).\n   */\n  async evaluate<T = unknown>(script: string): Promise<T> {\n    return this.command<T>({\n      action: \"eval\",\n      script,\n    });\n  }\n\n  /**\n   * Send a declarative command to the in-page harness via POST /command.\n   * Returns the structured result from the harness.\n   *\n   * Throws if the harness returns `{ ok: false }`.\n   */\n  async command<T = unknown>(payload: Record<string, unknown>): Promise<T> {\n    const res = await fetch(`${this.baseUrl}/command`, {\n      method: \"POST\",\n      headers: { \"Content-Type\": \"application/json\" },\n      body: JSON.stringify(payload),\n    });\n\n    const result: TransportResult<{ ok: boolean; value?: T; error?: string }> =\n      await res.json();\n\n    // The /command endpoint wraps the harness result in a TransportResult envelope.\n    // result.ok = true means the eval succeeded (harness didn't throw).\n    // result.value contains the CommandResult from the harness.\n    if (!result.ok) {\n      throw new Error(result.error ?? \"Command transport failed\");\n    }\n\n    const commandResult = result.value;\n    if (!commandResult || !commandResult.ok) {\n      throw new Error(\n        commandResult?.error ?? \"Command failed with unknown error\"\n      );\n    }\n\n    return commandResult.value as T;\n  }\n\n  /**\n   * Perform the protocol version handshake with the in-page harness.\n   * Returns true if the harness is available and compatible.\n   */\n  async handshake(): Promise<void> {\n    await this.command({\n      action: \"handshake\",\n      protocolVersion: PROTOCOL_VERSION,\n    });\n  }\n\n  // ─── Public API ─────────────────────────────────────────────────\n\n  /**\n   * Click an element matching the given target. Accepts a CSS selector\n   * string or any `Locator` object (e.g. `{ role: \"button\", name: \"Next\" }`\n   * for text-based button matching, or `{ testId: \"...\" }`).\n   * Auto-waits for the element to be visible before clicking.\n   * With `{ enabled: true }`, also waits for `!el.disabled` — useful for\n   * buttons gated by form validation.\n   */\n  async click(target: LocatorInput, options?: InteractionOptions): Promise<void> {\n    await this.command({\n      action: \"click\",\n      locator: toLocator(target),\n      options: {\n        timeout: options?.timeout ?? this.defaultTimeout,\n        enabled: options?.enabled,\n      },\n    });\n  }\n\n  /**\n   * Type text into an input/textarea matching the given target.\n   * Auto-waits for the element to be visible before typing.\n   * Finds the actual `<input>` or `<textarea>` element (even inside wrapper\n   * components — useful for Mantine, which puts `data-testid` on the\n   * wrapper `<div>`), sets the value using the React-compatible native\n   * setter, and dispatches input/change events so React's synthetic\n   * event system fires onChange handlers.\n   */\n  async type(\n    target: LocatorInput,\n    text: string,\n    options?: InteractionOptions\n  ): Promise<void> {\n    await this.command({\n      action: \"type\",\n      locator: toLocator(target),\n      text,\n      options: {\n        timeout: options?.timeout ?? this.defaultTimeout,\n      },\n    });\n  }\n\n  /**\n   * Get the text content of an element matching the given target.\n   * Auto-waits for the element to be visible before reading.\n   */\n  async textContent(\n    target: LocatorInput,\n    options?: InteractionOptions\n  ): Promise<string> {\n    return this.command<string>({\n      action: \"text-content\",\n      locator: toLocator(target),\n      options: {\n        timeout: options?.timeout ?? this.defaultTimeout,\n      },\n    });\n  }\n\n  /**\n   * Wait until an element matching the target is in the DOM and visible.\n   */\n  async waitFor(target: LocatorInput, options?: WaitOptions): Promise<void> {\n    await this.command({\n      action: \"wait-for\",\n      locator: toLocator(target),\n      options: {\n        timeout: options?.timeout ?? this.defaultTimeout,\n      },\n    });\n  }\n\n  /**\n   * Wait until an element matching the target contains the specified text.\n   */\n  async waitForText(\n    target: LocatorInput,\n    text: string,\n    options?: WaitOptions\n  ): Promise<void> {\n    await this.command({\n      action: \"wait-for-text\",\n      locator: toLocator(target),\n      text,\n      options: {\n        timeout: options?.timeout ?? this.defaultTimeout,\n      },\n    });\n  }\n\n  /**\n   * Wait until any of the given targets matches a visible element.\n   * Returns the target that matched, so the caller can branch.\n   */\n  async waitForAny<T extends LocatorInput>(\n    targets: T[],\n    options?: WaitOptions\n  ): Promise<T> {\n    const locators = targets.map(toLocator);\n    const matchedIndex = await this.command<number>({\n      action: \"wait-for-any\",\n      locators,\n      options: {\n        timeout: options?.timeout ?? this.defaultTimeout,\n      },\n    });\n    return targets[matchedIndex];\n  }\n\n  /**\n   * Wait until an element is no longer in the DOM.\n   */\n  async waitForGone(\n    target: LocatorInput,\n    options?: WaitOptions\n  ): Promise<void> {\n    await this.command({\n      action: \"wait-for-gone\",\n      locator: toLocator(target),\n      options: {\n        timeout: options?.timeout ?? this.defaultTimeout,\n      },\n    });\n  }\n\n  /**\n   * Invoke a Tauri command from the webview.\n   * Calls the Tauri backend directly via window.__TAURI_INTERNALS__.invoke().\n   */\n  async invoke<T = unknown>(\n    command: string,\n    args?: Record<string, unknown>\n  ): Promise<T> {\n    return this.command<T>({\n      action: \"invoke\",\n      command,\n      args: args ?? {},\n    });\n  }\n}\n\n// ─── Helpers ────────────────────────────────────────────────────────\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@phyto/driver-tauri",
+  "version": "0.1.5",
+  "description": "Tauri driver for Phyto — controls a running Tauri app via the tauri-plugin-phyto automation socket.",
+  "license": "MIT",
+  "author": "Coniferous <hello@coniferous.dev>",
+  "homepage": "https://github.com/coniferous-dev/phyto#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/coniferous-dev/phyto.git",
+    "directory": "packages/driver-tauri"
+  },
+  "bugs": {
+    "url": "https://github.com/coniferous-dev/phyto/issues"
+  },
+  "keywords": [
+    "phyto",
+    "tauri",
+    "driver",
+    "testing",
+    "e2e",
+    "automation"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "tsup": "^8.4.0",
+    "typescript": "~5.7.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}