@phone-use/sdk 0.4.0 → 0.5.0

package/dist/index.d.mts

@@ -477,10 +477,335 @@ declare function executeAction(core: DeviceCore, action: Action, opts?: ActOptio
  */
 declare function createAgentDeviceBackend(config?: DeviceConfig): DeviceBackend;
 //#endregion
+//#region src/lifecycle.d.ts
+/** The platform a {@link Device} runs on. */
+type DevicePlatform = 'ios' | 'android';
+/** Lifecycle state of a {@link Device} handle. */
+type DeviceStatus = 'running' | 'closed';
+/**
+ * The Device lifecycle handle: id, pinned backend, close/dispose, idle lease +
+ * reaper — plus the action verb surface layered onto the same type.
+ * `ios.launch()`/`ios.connect()` and `android.launch()`/`android.connect()`
+ * all return it, built over `createDeviceHandle`.
+ */
+interface Device {
+  /** udid (iOS) / serial (Android). */
+  readonly id: string;
+  /** Which platform this device runs. */
+  readonly platform: DevicePlatform;
+  /** Simulator/device name when known. */
+  readonly name?: string | undefined;
+  /** Name of the backend driving this device. */
+  readonly backendName: string;
+  /** The backend's declared capability set. */
+  readonly capabilities: ReadonlySet<Capability>;
+  /**
+   * The pinned backend — `new DeviceContext(device.backend)` works today.
+   * Backend calls through this handle count as activity for the idle lease.
+   */
+  readonly backend: DeviceBackend;
+  /** true when launch() created the device — close() then also deletes it. */
+  readonly createdByUs: boolean;
+  /** Current lifecycle state. */
+  readonly status: DeviceStatus;
+  /** Sugar for `status === 'closed'`. */
+  readonly isClosed: boolean;
+  /** Re-arm the idle lease (ms overrides the configured window for this arm only). */
+  extendLease(ms?: number): void;
+  /** Canonical, idempotent shutdown. `await using` is sugar over this. */
+  close(): Promise<void>;
+  /** `await using` support — delegates to {@link Device.close}. */
+  [Symbol.asyncDispose](): Promise<void>;
+  /** Look at the screen: elements + rendered text + portable Action[]. */
+  observe(opts?: {
+    signal?: AbortSignal | undefined;
+  }): Promise<ObserveResult>;
+  /** Tap by label/id query. Auto-waits; never throws for normal outcomes. */
+  tap(target: string | ElementQuery, opts?: ActOptions): Promise<ActionResult>;
+  /** Type text (optionally into a field resolved by query); %name% secrets substituted. */
+  type(text: string, opts?: ActOptions & {
+    field?: string | ElementQuery | undefined;
+    submit?: boolean | undefined;
+  }): Promise<ActionResult>;
+  /** Execute a portable Action deterministically — no re-inference. */
+  act(action: Action, opts?: ActOptions): Promise<ActionResult>;
+  /** App management: open by name/deep link, list installed, current app. */
+  readonly apps: {
+    /** Open an app by name/bundle id, or a deep link when `url` is set. */
+    open(app: string, opts?: {
+      relaunch?: boolean | undefined;
+      url?: string | undefined;
+      signal?: AbortSignal | undefined;
+    }): Promise<ActionResult>;
+    /** List installed app bundle ids. */
+    list(opts?: {
+      signal?: AbortSignal | undefined;
+    }): Promise<string[]>;
+    /** The frontmost app name from the last observation (no new snapshot). */
+    current(): string | undefined;
+  };
+  /** Screen-level verbs: scroll, screenshot, waitForText, alert, back, home. */
+  readonly screen: {
+    /** Scroll the active scroll view one step. */
+    scroll(direction: ScrollDirection, opts?: {
+      signal?: AbortSignal | undefined;
+    }): Promise<ActionResult>;
+    /** Save a screenshot to `path`. */
+    screenshot(opts: {
+      path: string;
+      signal?: AbortSignal | undefined;
+    }): Promise<{
+      success: boolean;
+      message: string;
+      path?: string | undefined;
+    }>;
+    /** Block until `text` appears on screen or the timeout elapses. */
+    waitForText(text: string, opts?: {
+      timeoutMs?: number | undefined;
+      signal?: AbortSignal | undefined;
+    }): Promise<ActionResult>;
+    /** Read ('get'), accept, or dismiss a blocking system alert. */
+    alert(action: 'get' | 'accept' | 'dismiss', opts?: {
+      signal?: AbortSignal | undefined;
+    }): Promise<ActionResult>;
+    /** Navigate back. */
+    back(opts?: {
+      signal?: AbortSignal | undefined;
+    }): Promise<ActionResult>;
+    /** Go to the home screen. */
+    home(opts?: {
+      signal?: AbortSignal | undefined;
+    }): Promise<ActionResult>;
+  };
+  /** %name% secret store — values substituted at execution, redacted everywhere else. */
+  readonly secrets: SecretStore;
+}
+/** Inputs to {@link createDeviceHandle} — what an engine supplies per device. */
+type CreateDeviceHandleOptions = {
+  /** udid (iOS) / serial (Android). */
+  id: string;
+  /** Which platform the device runs. */
+  platform: DevicePlatform;
+  /** Simulator/device name when known. */
+  name?: string | undefined;
+  /** The backend pinned to this device. */
+  backend: DeviceBackend;
+  /** true when the engine created the device (close() then also deletes it). */
+  createdByUs: boolean;
+  /** Idle window in ms; false disables the lease. Default 180_000 (3m). */
+  idleTimeoutMs?: number | false | undefined;
+  /** Observer for reaper-initiated closes (the SDK never logs). */
+  onIdleClose?: ((device: Device) => void) | undefined;
+  /** Initial %name% secret values. */
+  secrets?: Record<string, string> | undefined;
+  /** Platform teardown: shutdown (+ delete when createdByUs). */
+  doClose: () => Promise<void>;
+};
+/**
+ * Assemble a Device handle over a backend: lease/reaper, verb surface,
+ * close/dispose semantics. Engine authors (ios and android here,
+ * phone-backend-* third parties) build on this; tests fabricate devices with
+ * it over a FakeBackend.
+ */
+declare function createDeviceHandle(opts: CreateDeviceHandleOptions): Device;
+//#endregion
+//#region src/backends/android.d.ts
+/** Binary-stdout runner for `adb exec-out` (screencap). Resolves with the raw bytes. */
+type BinaryExecRunner = (file: string, args: string[], opts?: {
+  timeoutMs?: number | undefined;
+}) => Promise<Uint8Array>;
+/** Options for {@link AndroidBackend} / {@link createAndroidBackend}. */
+type AndroidBackendOptions = {
+  /** adb serial to target (`adb -s`); omit when exactly one device is attached. */
+  serial?: string | undefined;
+  /** Path to the adb binary (default: `adb` on PATH). */
+  adbBin?: string | undefined;
+  /** Per-command ceiling in ms before a hung adb call rejects with TimeoutError (default 30_000). */
+  commandTimeoutMs?: number | undefined;
+};
+/**
+ * Drive an Android device or emulator over adb. Implements the
+ * {@link DeviceBackend} contract with uiautomator for the tree, screencap for
+ * pixels, and `input` for gestures. Stateless across calls except the ref → rect
+ * map from the last snapshot (what makes press-by-ref work).
+ */
+declare class AndroidBackend extends BaseDeviceBackend {
+  private readonly serial;
+  private readonly adbBin;
+  private readonly timeoutMs;
+  private readonly exec;
+  private readonly execBinary;
+  private readonly sleep;
+  private rects;
+  private sizeCache;
+  private launchablesCache;
+  constructor(opts?: AndroidBackendOptions);
+  private withSerial;
+  /** Normalize an exec failure into the PhoneUseError the contract promises. */
+  private fail;
+  /** Run an adb command, returning stdout text. */
+  private adb;
+  /** `adb shell <argv>` — each argument quoted for the device shell. */
+  private shell;
+  /** `adb shell <literal>` for the few CONSTANT commands that need a pipe. Never pass input. */
+  private shellRaw;
+  private center;
+  /** The screen size input coordinates map to (an `Override size` wins over `Physical size`). */
+  private screenSize;
+  snapshot(opts?: {
+    interactiveOnly?: boolean | undefined;
+  }): Promise<Snapshot>;
+  /** The package of the resumed (frontmost) activity, for the snapshot header. */
+  private foregroundPackage;
+  screenshot(opts: {
+    path: string;
+  }): Promise<{
+    path: string;
+  }>;
+  press(target: PressTarget): Promise<void>;
+  longPress(ref: string, durationMs?: number): Promise<void>;
+  fill(ref: string, text: string): Promise<void>;
+  /**
+   * Empty the currently-focused text field. Ctrl+A then DEL (`input
+   * keycombination`, Android 12+); a short MOVE_END + backspace sweep stays as
+   * the fallback for the rare field that ignores the select combo. Replaces a
+   * 60-backspace sweep that left residue on long fields and made repeated
+   * `type`s ACCUMULATE, sending the agent into retry loops.
+   */
+  private clearFocusedField;
+  typeText(text: string): Promise<void>;
+  /** The IME id of senzhk/ADBKeyBoard, the de-facto Unicode input path for adb. */
+  private static readonly ADB_IME;
+  /**
+   * Type non-ASCII via the ADB Keyboard broadcast. The IME must be the ACTIVE
+   * keyboard; some OEM builds deny the shell WRITE_SECURE_SETTINGS so `ime set`
+   * cannot switch it. We try (works on stock builds) and restore the previous
+   * keyboard afterwards when we did the switching. Never a silent drop.
+   */
+  private typeUnicode;
+  pressKey(_key: 'return'): Promise<void>;
+  scroll(direction: ScrollDirection): Promise<void>;
+  pan(x: number, y: number, dx: number, dy: number, durationMs?: number): Promise<void>;
+  waitForText(text: string, timeoutMs?: number): Promise<void>;
+  home(): Promise<void>;
+  back(): Promise<void>;
+  /** Packages that expose a launcher icon — the set `open <name>` can resolve to. */
+  private launchables;
+  /**
+   * Resolve a human app name to an installed package: agents say "Markor" or
+   * "Simple Calendar", `am` needs `net.gsantner.markor`. Score each launchable
+   * package by how many of the query's words appear in its id; best (shortest
+   * on a tie) wins. An exact package id passes straight through. Returns
+   * undefined when nothing matches and the query is not a package id at all.
+   */
+  private resolvePackage;
+  openApp(opts: {
+    app?: string | undefined;
+    url?: string | undefined;
+    relaunch?: boolean | undefined;
+  }): Promise<OpenAppResult>;
+  listApps(): Promise<string[]>;
+  closeSession(): Promise<void>;
+}
+/**
+ * Backend factory for the `android-adb` registry entry: an
+ * {@link AndroidDeviceConfig} pins the serial; anything else targets the single
+ * attached device.
+ */
+declare function createAndroidBackend(config?: DeviceConfig | AndroidBackendOptions): AndroidBackend;
+/** One row of `adb devices -l`. */
+type AndroidDeviceInfo = {
+  /** adb serial, e.g. `emulator-5554` or `R58M12ABCDE`. */
+  serial: string;
+  /** adb state: `device` (ready), `unauthorized`, `offline`, … */
+  state: string;
+  /** Model name when adb reports one. */
+  model?: string | undefined;
+};
+type CommonAndroidOptions = {
+  /** Path to the adb binary (default: `adb` on PATH). */
+  adbBin?: string | undefined;
+  /** Idle lease window in ms (false disables). Default 180_000 (3 min). */
+  idleTimeoutMs?: number | false | undefined;
+  /** Observer for reaper-initiated closes. */
+  onIdleClose?: ((device: Device) => void) | undefined;
+  /** Initial %name% secret values (see Device.secrets). */
+  secrets?: Record<string, string> | undefined;
+};
+/** Options for `android.connect()`. */
+type AndroidConnectOptions = CommonAndroidOptions;
+/** Options for `android.list()`. */
+type AndroidListOptions = {
+  /** Path to the adb binary (default: `adb` on PATH). */
+  adbBin?: string | undefined;
+};
+/** The child-process handle the emulator spawner returns (what `android.launch()` kills on close). */
+type EmulatorProcess = {
+  /** Send a signal to the emulator process. */
+  kill(signal?: NodeJS.Signals): void;
+  /** Subscribe once to process exit. */
+  once(event: 'exit', listener: () => void): unknown;
+  /** True once the process has exited. */
+  readonly exited: boolean;
+};
+/** Options for `android.launch()` — which AVD, which port, headless or not. */
+type AndroidLaunchOptions = CommonAndroidOptions & {
+  /** The AVD name (`emulator -list-avds`). Required. */
+  avd: string;
+  /** Console port; the serial becomes `emulator-<port>`. Default 5554. Must be even. */
+  port?: number | undefined;
+  /** Path to the `emulator` binary (default: `$ANDROID_HOME/emulator/emulator`, else `emulator` on PATH). */
+  emulatorBin?: string | undefined;
+  /** Run without a window (default true — cloud hosts have no display). */
+  headless?: boolean | undefined;
+  /** `-read-only`: lets several instances of ONE AVD run at once (what a cloud worker wants). */
+  readOnly?: boolean | undefined;
+  /** Extra emulator arguments appended verbatim (e.g. `-gpu swiftshader_indirect`). */
+  extraArgs?: string[] | undefined;
+  /** Boot ceiling in ms for `sys.boot_completed` (default 180_000). */
+  bootTimeoutMs?: number | undefined;
+};
+/** Devices adb currently sees, with their state. */
+declare function list(options?: AndroidListOptions): Promise<AndroidDeviceInfo[]>;
+/**
+ * Attach to a device adb already sees. With a serial, that device; without,
+ * the single ready device (several attached → an error naming them, so verbs
+ * never land on the wrong phone). `close()` releases the handle and never
+ * shuts the device down — it was yours before we connected.
+ */
+declare function connect$1(serial?: string, options?: AndroidConnectOptions): Promise<Device>;
+/**
+ * Boot a DEDICATED emulator instance from an AVD and return a {@link Device}
+ * pinned to its serial (`emulator-<port>`). `close()` kills the instance.
+ * `readOnly: true` lets several instances of one AVD run side by side, which
+ * is how a cloud worker turns one golden image into N phones.
+ */
+declare function launch$1(options: AndroidLaunchOptions): Promise<Device>;
+/**
+ * The Android engine object (the `ios` twin): `android.connect()` for a device
+ * adb already sees, `android.launch()` for a dedicated emulator instance,
+ * `android.list()` to see what is attached. All return/describe the same
+ * Device type the iOS engine does.
+ */
+declare const android: {
+  /** Attach to an attached device or running emulator by serial (no-arg: the single ready device). */
+  readonly connect: typeof connect$1;
+  /** Boot a dedicated emulator instance from an AVD and return a Device pinned to it. */
+  readonly launch: typeof launch$1;
+  /** Devices adb currently sees, with their state. */
+  readonly list: typeof list;
+};
+//#endregion
 //#region src/backends/cloud-sandbox.d.ts
 /** Every device verb a cloud sandbox accepts over the RPC wire. The worker's
  * runtime set is contract-tested against this union. */
-type SandboxRpcMethod = 'snapshot' | 'screenshot' | 'press' | 'longPress' | 'fill' | 'typeText' | 'pressKey' | 'scroll' | 'pan' | 'installApp' | 'waitForText' | 'systemAlert' | 'home' | 'back' | 'openApp' | 'listApps' | 'closeSession';
+type SandboxRpcMethod = 'snapshot' | 'screenshot' | 'press' | 'longPress' | 'fill' | 'typeText' | 'pressKey' | 'scroll' | 'pan' | 'installApp' | 'waitForText' | 'systemAlert' | 'home' | 'back' | 'openApp' | 'listApps' | 'closeSession' | 'checkpoint' | 'restoreCheckpoint' | 'listCheckpoints' | 'deleteCheckpoint';
+/** One saved device state, as reported by the worker. */
+type SandboxCheckpointInfo = {
+  id: string;
+  label?: string | undefined;
+  createdAt: string;
+};
 /** Body of `POST <endpoint>/rpc`: one verb and its positional arguments. */
 type SandboxRpcRequest = {
   method: SandboxRpcMethod;
@@ -546,7 +871,33 @@ declare class CloudSandboxBackend extends BaseDeviceBackend {
   }): Promise<OpenAppResult>;
   listApps(): Promise<string[]>;
   closeSession(): Promise<void>;
+  /** Save the device's current state. Returns the checkpoint's id. */
+  checkpoint(opts?: {
+    label?: string;
+  }): Promise<SandboxCheckpointInfo>;
+  /** Restore a checkpoint by id or label. The checkpoint survives — restore as
+   * often as needed. Device identity may change server-side; the sandbox
+   * endpoint/token stay valid. */
+  restoreCheckpoint(ref: string): Promise<{
+    checkpointId: string;
+  }>;
+  /** List this sandbox's checkpoints. */
+  listCheckpoints(): Promise<SandboxCheckpointInfo[]>;
+  /** Delete a checkpoint by id or label. */
+  deleteCheckpoint(ref: string): Promise<{
+    deleted: boolean;
+  }>;
   /** Upload a zipped .app bundle (base64) and install it on the sandbox device. */
+  /**
+   * Upload a zipped .app as a raw stream. Prefer this over {@link installApp}:
+   * base64 inside a JSON body inflates the payload by a third, which caps real
+   * apps near 144MB. Pass a `Bun.file(...)` (or any Blob) and the bytes go to the
+   * wire without being buffered in memory.
+   */
+  installAppStream(zip: Blob): Promise<{
+    installed?: string;
+  }>;
+  /** @deprecated Base64-in-JSON; use {@link installAppStream}. */
   installApp(base64Zip: string): Promise<{
     installed?: string;
   }>;
@@ -620,138 +971,6 @@ declare class DeviceRunnerBackend extends BaseDeviceBackend {
  * `PHONE_USE_RUNNER_URL` / `PHONE_USE_RUNNER_TOKEN` when `config` is omitted). */
 declare const createDeviceRunnerBackend: (config?: DeviceRunnerConfig) => DeviceRunnerBackend;
 //#endregion
-//#region src/lifecycle.d.ts
-/** The platform a {@link Device} runs on. */
-type DevicePlatform = 'ios' | 'android';
-/** Lifecycle state of a {@link Device} handle. */
-type DeviceStatus = 'running' | 'closed';
-/**
- * The Device lifecycle handle: id, pinned backend, close/dispose, idle lease +
- * reaper — plus the action verb surface layered onto the same type.
- * `ios.launch()` and `ios.connect()` return it; the future android engine will
- * share `createDeviceHandle`.
- */
-interface Device {
-  /** udid (iOS) / serial (Android). */
-  readonly id: string;
-  /** Which platform this device runs. */
-  readonly platform: DevicePlatform;
-  /** Simulator/device name when known. */
-  readonly name?: string | undefined;
-  /** Name of the backend driving this device. */
-  readonly backendName: string;
-  /** The backend's declared capability set. */
-  readonly capabilities: ReadonlySet<Capability>;
-  /**
-   * The pinned backend — `new DeviceContext(device.backend)` works today.
-   * Backend calls through this handle count as activity for the idle lease.
-   */
-  readonly backend: DeviceBackend;
-  /** true when launch() created the device — close() then also deletes it. */
-  readonly createdByUs: boolean;
-  /** Current lifecycle state. */
-  readonly status: DeviceStatus;
-  /** Sugar for `status === 'closed'`. */
-  readonly isClosed: boolean;
-  /** Re-arm the idle lease (ms overrides the configured window for this arm only). */
-  extendLease(ms?: number): void;
-  /** Canonical, idempotent shutdown. `await using` is sugar over this. */
-  close(): Promise<void>;
-  /** `await using` support — delegates to {@link Device.close}. */
-  [Symbol.asyncDispose](): Promise<void>;
-  /** Look at the screen: elements + rendered text + portable Action[]. */
-  observe(opts?: {
-    signal?: AbortSignal | undefined;
-  }): Promise<ObserveResult>;
-  /** Tap by label/id query. Auto-waits; never throws for normal outcomes. */
-  tap(target: string | ElementQuery, opts?: ActOptions): Promise<ActionResult>;
-  /** Type text (optionally into a field resolved by query); %name% secrets substituted. */
-  type(text: string, opts?: ActOptions & {
-    field?: string | ElementQuery | undefined;
-    submit?: boolean | undefined;
-  }): Promise<ActionResult>;
-  /** Execute a portable Action deterministically — no re-inference. */
-  act(action: Action, opts?: ActOptions): Promise<ActionResult>;
-  /** App management: open by name/deep link, list installed, current app. */
-  readonly apps: {
-    /** Open an app by name/bundle id, or a deep link when `url` is set. */
-    open(app: string, opts?: {
-      relaunch?: boolean | undefined;
-      url?: string | undefined;
-      signal?: AbortSignal | undefined;
-    }): Promise<ActionResult>;
-    /** List installed app bundle ids. */
-    list(opts?: {
-      signal?: AbortSignal | undefined;
-    }): Promise<string[]>;
-    /** The frontmost app name from the last observation (no new snapshot). */
-    current(): string | undefined;
-  };
-  /** Screen-level verbs: scroll, screenshot, waitForText, alert, back, home. */
-  readonly screen: {
-    /** Scroll the active scroll view one step. */
-    scroll(direction: ScrollDirection, opts?: {
-      signal?: AbortSignal | undefined;
-    }): Promise<ActionResult>;
-    /** Save a screenshot to `path`. */
-    screenshot(opts: {
-      path: string;
-      signal?: AbortSignal | undefined;
-    }): Promise<{
-      success: boolean;
-      message: string;
-      path?: string | undefined;
-    }>;
-    /** Block until `text` appears on screen or the timeout elapses. */
-    waitForText(text: string, opts?: {
-      timeoutMs?: number | undefined;
-      signal?: AbortSignal | undefined;
-    }): Promise<ActionResult>;
-    /** Read ('get'), accept, or dismiss a blocking system alert. */
-    alert(action: 'get' | 'accept' | 'dismiss', opts?: {
-      signal?: AbortSignal | undefined;
-    }): Promise<ActionResult>;
-    /** Navigate back. */
-    back(opts?: {
-      signal?: AbortSignal | undefined;
-    }): Promise<ActionResult>;
-    /** Go to the home screen. */
-    home(opts?: {
-      signal?: AbortSignal | undefined;
-    }): Promise<ActionResult>;
-  };
-  /** %name% secret store — values substituted at execution, redacted everywhere else. */
-  readonly secrets: SecretStore;
-}
-/** Inputs to {@link createDeviceHandle} — what an engine supplies per device. */
-type CreateDeviceHandleOptions = {
-  /** udid (iOS) / serial (Android). */
-  id: string;
-  /** Which platform the device runs. */
-  platform: DevicePlatform;
-  /** Simulator/device name when known. */
-  name?: string | undefined;
-  /** The backend pinned to this device. */
-  backend: DeviceBackend;
-  /** true when the engine created the device (close() then also deletes it). */
-  createdByUs: boolean;
-  /** Idle window in ms; false disables the lease. Default 180_000 (3m). */
-  idleTimeoutMs?: number | false | undefined;
-  /** Observer for reaper-initiated closes (the SDK never logs). */
-  onIdleClose?: ((device: Device) => void) | undefined;
-  /** Initial %name% secret values. */
-  secrets?: Record<string, string> | undefined;
-  /** Platform teardown: shutdown (+ delete when createdByUs). */
-  doClose: () => Promise<void>;
-};
-/**
- * Assemble a Device handle over a backend: lease/reaper, verb surface,
- * close/dispose semantics. Engine authors (ios here, android in item 7b,
- * phone-backend-* third parties) build on this; tests fabricate devices with
- * it over a FakeBackend.
- */
-declare function createDeviceHandle(opts: CreateDeviceHandleOptions): Device;
-//#endregion
 //#region src/backends/ios.d.ts
 type CommonIosOptions = {
   /** Custom simulator device set directory (maps to `simctl --set`). */
@@ -819,14 +1038,14 @@ declare const ios: {
 //#region src/index.d.ts
 /**
  * @phone-use/sdk — the device runtime SDK: engine-as-object lifecycle
- * (ios.launch/connect → Device), Device backends, config, errors, capabilities,
+ * (ios.launch/connect and android.launch/connect → Device), Device backends, config, errors, capabilities,
  * and the action verb surface.
  *
  * The test double (FakeBackend) lives on the "@phone-use/sdk/testing" subpath,
  * deliberately not re-exported here.
  */
 /** The published package version (kept in sync with package.json by the release flow). */
-declare const VERSION = "0.3.1";
+declare const VERSION = "0.5.0";
 //#endregion
-export { ALL_CAPABILITIES, AbortedError, type ActOptions, type Action, type ActionEvidence, ActionFailedError, type ActionResult, type ActionVerb, type AlertAction, type AlertOutcome, type AndroidDeviceConfig, type BackendAlertResult, type BackendFactory, BaseDeviceBackend, type Capability, CloudSandboxBackend, type CloudSandboxBackendOptions, type CommonDeviceConfig, type CompiledSkill, type CreateDeviceHandleOptions, type Device, type DeviceBackend, type DeviceConfig, DeviceCore, DeviceInUseError, DeviceNotFoundError, type DevicePlatform, DeviceRunnerBackend, type DeviceRunnerConfig, type DeviceStatus, type ElementQuery, type IosConnectOptions, type IosDeviceConfig, type IosLaunchOptions, type Observation, type ObserveResult, type ObservedElement, type OpenAppResult, PhoneUseError, type PhoneUseErrorCode, type PhoneUseErrorDetails, type PressTarget, type Rect, type RenderState, type Resolution, type ResolveOpts, type SandboxRpcFailure, type SandboxRpcMethod, type SandboxRpcRequest, type SandboxRpcResponse, type SandboxRpcSuccess, type ScrollDirection, SecretStore, SessionNotFoundError, type Snapshot, type SnapshotNode, TimeoutError, type UiElement, UnsupportedCapabilityError, VERSION, buildObserveResult, createAgentDeviceBackend, createCloudSandboxBackend, createDeviceHandle, createDeviceRunnerBackend, describeError, executeAction, getBackendFactory, ios, labelMatches, listBackends, matchInElements, registerBackend, toActions, toPhoneUseError };
+export { ALL_CAPABILITIES, AbortedError, type ActOptions, type Action, type ActionEvidence, ActionFailedError, type ActionResult, type ActionVerb, type AlertAction, type AlertOutcome, AndroidBackend, type AndroidBackendOptions, type AndroidConnectOptions, type AndroidDeviceConfig, type AndroidDeviceInfo, type AndroidLaunchOptions, type AndroidListOptions, type BackendAlertResult, type BackendFactory, BaseDeviceBackend, type BinaryExecRunner, type Capability, CloudSandboxBackend, type CloudSandboxBackendOptions, type CommonDeviceConfig, type CompiledSkill, type CreateDeviceHandleOptions, type Device, type DeviceBackend, type DeviceConfig, DeviceCore, DeviceInUseError, DeviceNotFoundError, type DevicePlatform, DeviceRunnerBackend, type DeviceRunnerConfig, type DeviceStatus, type ElementQuery, type EmulatorProcess, type IosConnectOptions, type IosDeviceConfig, type IosLaunchOptions, type Observation, type ObserveResult, type ObservedElement, type OpenAppResult, PhoneUseError, type PhoneUseErrorCode, type PhoneUseErrorDetails, type PressTarget, type Rect, type RenderState, type Resolution, type ResolveOpts, type SandboxCheckpointInfo, type SandboxRpcFailure, type SandboxRpcMethod, type SandboxRpcRequest, type SandboxRpcResponse, type SandboxRpcSuccess, type ScrollDirection, SecretStore, SessionNotFoundError, type Snapshot, type SnapshotNode, TimeoutError, type UiElement, UnsupportedCapabilityError, VERSION, android, buildObserveResult, createAgentDeviceBackend, createAndroidBackend, createCloudSandboxBackend, createDeviceHandle, createDeviceRunnerBackend, describeError, executeAction, getBackendFactory, ios, labelMatches, listBackends, matchInElements, registerBackend, toActions, toPhoneUseError };
 //# sourceMappingURL=index.d.mts.map