@delacour/warden-e2e 0.0.0-stage → 0.1.0

package/types/e2e/src/driver/android/uiad-dex.generated.d.ts

@@ -0,0 +1,8 @@
+export declare const UIAD_DEX: {
+    readonly protocol: 1;
+    readonly version: "0.3.0";
+    readonly bytes: 31124;
+    readonly dexSha256: "d6cb11a3bffc6b00d3ea46c4fdd1721c23973b72b0769f26c2478e7a1769be4c";
+    readonly sourceSha256: "d03ff47b9a5890fcc8de5d76b504b05c90402edda60ac69f765c78ec8195cfdc";
+    readonly base64: "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";
+};

package/types/e2e/src/driver/android/uiad-ops.d.ts

@@ -0,0 +1,62 @@
+import type { DriverResult, Logger, Point, ScreenInfo, Snapshot } from "../driver.types";
+import type { GesturePlan } from "../gesture-geometry";
+import type { SettleDetail } from "../settle";
+import { type Clock } from "./android-device";
+import type { UiadBackend } from "./uiad-backend";
+import type { UiadSnapshotData } from "./uiad-protocol";
+/**
+ * What the Android driver asks of `warden-uiad`, one method per thing the server does faster than `uiautomator dump`
+ * and `input`. Every method answers `undefined` when the server is not the way to do that call (it is off, it could
+ * not start, or it refused this one op) and the driver then does it the old way; a result, success or error, is final.
+ *
+ * Which failures fall back and which are surfaced:
+ * - the op was refused (`E_HID`, `E_NO_ELEMENT`, `E_UNSUPPORTED`): nothing happened, the server is fine, this call
+ *   falls back (a `typeText` with nothing focused is typed by `input text` as before);
+ * - the server died, hung or sent nonsense: it is stopped, so the dump can have UiAutomation again, and the next call
+ *   starts a new one. A read (`snapshot`, `settle`, `selectAll`) falls back; a tap, swipe, key or typed text is
+ *   surfaced, because it may have happened and doing it twice is worse than a failed step;
+ * - the request never left (the server had already gone): started again and sent again, once.
+ */
+/** A settled `DriverResult`. */
+type Res<T> = Awaited<DriverResult<T>>;
+export type Maybe<T> = Promise<Res<T> | undefined>;
+export type UiadOps = {
+    /** the server is on and has not been given up on: what `capabilities` reports */
+    enabled(): boolean;
+    /** `up`, `idle`, `busy`, or `off: <why>`: for `health` */
+    status(): string;
+    snapshot(): Maybe<Snapshot>;
+    settle(opts: {
+        quietMs: number;
+        timeoutMs: number;
+    }): Maybe<SettleDetail>;
+    tap(point: Point, opts?: {
+        count?: number;
+        durationMs?: number;
+    }): Maybe<void>;
+    longPress(point: Point, durationMs?: number): Maybe<void>;
+    swipe(from: Point, to: Point, durationMs?: number): Maybe<void>;
+    drag(from: Point, to: Point, timing: {
+        pressMs: number;
+        durationMs: number;
+        releaseMs: number;
+    }): Maybe<void>;
+    /** replay a 1-2 finger plan as one multi-pointer MotionEvent stream (`gesture` op, server 0.3.0+) */
+    gesture(plan: GesturePlan): Maybe<void>;
+    key(keyCode: number, times?: number): Maybe<void>;
+    selectAll(): Maybe<void>;
+    typeText(text: string): Maybe<void>;
+    /** replace the whole text of the focused input (`ACTION_SET_TEXT`); `undefined` = refused or no server */
+    setText(text: string): Maybe<void>;
+    stop(): Promise<void>;
+};
+export type UiadOpsDeps = {
+    backend: UiadBackend;
+    baseScreen: ScreenInfo;
+    clock: Clock;
+    log?: Logger;
+};
+/** The `Snapshot` the driver builds from a server reply: the same tree the dump of that screen gives. */
+export declare function snapshotFromUiad(data: UiadSnapshotData, baseScreen: ScreenInfo, takenAt: number): Snapshot;
+export declare function createUiadOps(deps: UiadOpsDeps): UiadOps;
+export {};

package/types/e2e/src/driver/android/uiad-protocol.d.ts

@@ -0,0 +1,209 @@
+import { z } from "zod";
+import { responseSchema, type WireError } from "../ios/simd-protocol";
+/**
+ * Wire format of `warden-uiad` (plan WDN-PERF, "Android server (PERF-3.2)"), the resident UiAutomation server in
+ * `native/android/`. The same NDJSON shapes as `warden-simd` (`ios/simd-protocol.ts`, whose framing, `log` / `fatal`
+ * events, responses and error mapping it reuses): requests `{id, op, ...params}`; replies `{id, ok:true, data}` /
+ * `{id, ok:false, error}`; events `{event:"ready"|"log"|"fatal", ...}`. Unlike simd the server runs one op at a
+ * time, so replies come back in request order.
+ */
+export declare const UIAD_PROTOCOL = 1;
+/** The class the dex's `Main` lives in; `app_process <dir> <class>` starts it and `ps` shows it. */
+export declare const UIAD_MAIN_CLASS = "nz.co.delacour.warden.uiad.Main";
+/**
+ * One accessibility node, with the attributes `uiautomator dump` writes under nearly the same names (a flag that is
+ * false is absent, `disabled` is true only for a disabled node, `invisible` only for a node that is not visible to the
+ * user). `bounds` is `[left, top, right, bottom]` in screen pixels, clipped to the display like the dump's.
+ */
+export type UiadNode = {
+    class?: string;
+    pkg?: string;
+    /** the raw `resource-id`, `pkg:id/name` for platform ids and the bare testID for React Native */
+    id?: string;
+    text?: string;
+    desc?: string;
+    hint?: string;
+    bounds: readonly [number, number, number, number];
+    clickable?: boolean;
+    longClickable?: boolean;
+    checkable?: boolean;
+    checked?: boolean;
+    scrollable?: boolean;
+    selected?: boolean;
+    focused?: boolean;
+    focusable?: boolean;
+    password?: boolean;
+    editable?: boolean;
+    disabled?: boolean;
+    invisible?: boolean;
+    /** drawing order among siblings */
+    order?: number;
+    children?: UiadNode[];
+};
+/**
+ * A node read off the wire, or why it is not one. Hand-written rather than zod: a snapshot is hundreds of nodes and
+ * this runs on every one, with no allocation beyond the node itself.
+ */
+export declare function readNode(value: unknown, path?: string): UiadNode | string;
+/** What `health` and the `ready` event carry. Unknown fields are kept (a newer server may add some). */
+export declare const healthSchema: z.ZodObject<{
+    version: z.ZodString;
+    protocol: z.ZodNumber;
+    sdk: z.ZodNumber;
+    release: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    uid: z.ZodOptional<z.ZodNumber>;
+    pid: z.ZodOptional<z.ZodNumber>;
+    uiAutomation: z.ZodObject<{
+        state: z.ZodString;
+        connect: z.ZodOptional<z.ZodString>;
+        connectMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$loose>;
+    events: z.ZodOptional<z.ZodObject<{
+        count: z.ZodNumber;
+        lastAgoMs: z.ZodNumber;
+    }, z.core.$loose>>;
+    uptimeMs: z.ZodOptional<z.ZodNumber>;
+    screen: z.ZodOptional<z.ZodObject<{
+        width: z.ZodNumber;
+        height: z.ZodNumber;
+        scale: z.ZodOptional<z.ZodNumber>;
+        rotation: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    displayError: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type UiadHealth = z.infer<typeof healthSchema>;
+export declare const settleDataSchema: z.ZodObject<{
+    quiet: z.ZodBoolean;
+    waitedMs: z.ZodNumber;
+    via: z.ZodLiteral<"events">;
+    events: z.ZodNumber;
+    firstEventMs: z.ZodOptional<z.ZodNumber>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type UiadSettleData = z.infer<typeof settleDataSchema>;
+export declare const textDataSchema: z.ZodObject<{
+    text: z.ZodString;
+    caret: z.ZodOptional<z.ZodNumber>;
+    caretPlaced: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+export type UiadTextData = z.infer<typeof textDataSchema>;
+export type UiadSnapshotData = {
+    backend: "uiad";
+    screen: {
+        width: number;
+        height: number;
+        scale?: number;
+        rotation?: number;
+    };
+    windows?: unknown[];
+    elements: UiadNode[];
+    truncated: boolean;
+    nodes: number;
+    readMs: number;
+    ms: number;
+};
+/** The data of a `snapshot` reply, with every node checked; a string is why it is not one. */
+export declare function readSnapshotData(data: unknown): UiadSnapshotData | string;
+export declare const readyEventSchema: z.ZodObject<{
+    event: z.ZodLiteral<"ready">;
+    protocol: z.ZodNumber;
+    version: z.ZodString;
+    data: z.ZodObject<{
+        version: z.ZodString;
+        protocol: z.ZodNumber;
+        sdk: z.ZodNumber;
+        release: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodNumber>;
+        pid: z.ZodOptional<z.ZodNumber>;
+        uiAutomation: z.ZodObject<{
+            state: z.ZodString;
+            connect: z.ZodOptional<z.ZodString>;
+            connectMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>;
+        events: z.ZodOptional<z.ZodObject<{
+            count: z.ZodNumber;
+            lastAgoMs: z.ZodNumber;
+        }, z.core.$loose>>;
+        uptimeMs: z.ZodOptional<z.ZodNumber>;
+        screen: z.ZodOptional<z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            scale: z.ZodOptional<z.ZodNumber>;
+            rotation: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        displayError: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export type UiadReadyEvent = z.infer<typeof readyEventSchema>;
+export declare const eventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    event: z.ZodLiteral<"ready">;
+    protocol: z.ZodNumber;
+    version: z.ZodString;
+    data: z.ZodObject<{
+        version: z.ZodString;
+        protocol: z.ZodNumber;
+        sdk: z.ZodNumber;
+        release: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        uid: z.ZodOptional<z.ZodNumber>;
+        pid: z.ZodOptional<z.ZodNumber>;
+        uiAutomation: z.ZodObject<{
+            state: z.ZodString;
+            connect: z.ZodOptional<z.ZodString>;
+            connectMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>;
+        events: z.ZodOptional<z.ZodObject<{
+            count: z.ZodNumber;
+            lastAgoMs: z.ZodNumber;
+        }, z.core.$loose>>;
+        uptimeMs: z.ZodOptional<z.ZodNumber>;
+        screen: z.ZodOptional<z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            scale: z.ZodOptional<z.ZodNumber>;
+            rotation: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        displayError: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+}, z.core.$strip>, z.ZodObject<{
+    event: z.ZodLiteral<"log">;
+    level: z.ZodEnum<{
+        error: "error";
+        info: "info";
+        warn: "warn";
+        debug: "debug";
+    }>;
+    message: z.ZodString;
+    op: z.ZodOptional<z.ZodString>;
+    id: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    event: z.ZodLiteral<"fatal">;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        retryable: z.ZodOptional<z.ZodBoolean>;
+        detail: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>;
+}, z.core.$strip>], "event">;
+export type UiadEvent = z.infer<typeof eventSchema>;
+export type UiadResponse = z.infer<typeof responseSchema>;
+export type UiadMessage = {
+    kind: "event";
+    event: UiadEvent;
+} | {
+    kind: "response";
+    response: UiadResponse;
+};
+export type ParsedUiadLine = {
+    success: true;
+    message: UiadMessage;
+} | {
+    success: false;
+    reason: string;
+};
+export declare function parseUiadLine(line: string): ParsedUiadLine;
+/** Why the server could not start, from `fatal.error.detail.reason`. */
+export type FatalReason = "uiautomation_busy" | "connect_failed";
+export declare function fatalReason(error: WireError): FatalReason | undefined;

package/types/e2e/src/driver/android/uiautomator.d.ts

@@ -0,0 +1,33 @@
+import type { Element } from "../driver.types";
+import type { UiadNode } from "./uiad-protocol";
+/** Thrown when the text has no `<hierarchy>` (e.g. `ERROR: null root node returned by UiTestAutomationBridge.`). */
+export declare class UiautomatorParseError extends Error {
+    constructor(message: string);
+}
+export type ParsedTree = {
+    elements: Element[];
+    flat: Element[];
+};
+/**
+ * Parse `uiautomator dump` output into the normalized tree. Ids are preorder paths (`0`, `0.3`, `0.3.1`).
+ * Anything outside `<hierarchy>…</hierarchy>` (the `UI hierarchy dumped to:` trailer, which some images
+ * misspell `hierchary`) is ignored. Throws `UiautomatorParseError` when there is no hierarchy at all.
+ */
+export declare function parseUiautomatorXml(xml: string, screen: {
+    width: number;
+    height: number;
+}): ParsedTree;
+/**
+ * The normalized tree of a `warden-uiad` snapshot: the same `Element`s, ids and depths `parseUiautomatorXml` gives for
+ * the same screen (the server writes the dump's attributes and skips the same invisible nodes), without the XML.
+ */
+export declare function parseUiadNodes(nodes: readonly UiadNode[], screen: {
+    width: number;
+    height: number;
+}): ParsedTree;
+/**
+ * Keep clickable / long-clickable / checkable / scrollable / EditText nodes plus all their ancestors.
+ * Returns a new tree (inputs untouched) with ids and depths preserved; descendants of a kept node are
+ * only retained when they are interactive themselves.
+ */
+export declare function interactiveFilter(elements: readonly Element[]): ParsedTree;

package/types/e2e/src/driver/driver.types.d.ts

@@ -0,0 +1,231 @@
+import type { AsyncResult } from "../../../types/src/result";
+/**
+ * The device driver contract every layer of warden-e2e builds on: the spec API (`screen`, `device`,
+ * `app`), `warden ui`, specs and the devtools facet all talk to a `Driver`. Implementations:
+ * `ios/ios-driver.ts` (warden-simd over NDJSON + `xcrun simctl`) and `android/android-driver.ts`
+ * (persistent `adb shell` + uiautomator). `driver.testing.ts` has the scripted FakeDriver for tests.
+ *
+ * Frozen interface — change it only together with `docs/plans/wdn-e2e.md`.
+ */
+export type Platform = "ios" | "android";
+export type DriverErrorCode = "E_HELPER_MISSING" | "E_HELPER_CRASHED" | "E_TIMEOUT" | "E_NOT_BOOTED" | "E_UNKNOWN_DEVICE" | "E_AX_UNAVAILABLE" | "E_APP_UNAVAILABLE" | "E_APP_NOT_RESPONDING" | "E_NO_ELEMENT" | "E_STALE_REF" | "E_UNSUPPORTED" | "E_UNSUPPORTED_TEXT" | "E_HID" | "E_IO" | "E_BAD_REQUEST" | "E_INTERNAL";
+export type DriverError = {
+    code: DriverErrorCode;
+    message: string;
+    retryable: boolean;
+    detail?: unknown;
+};
+export type DriverResult<T> = AsyncResult<T, DriverError>;
+/** Points on iOS (portrait-up screen space, same as AX frames), px on Android. */
+export type Point = {
+    x: number;
+    y: number;
+};
+export type Rect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/** A point on one finger's route; `t` = ms after touch-down. Every point of a gesture carries `t`, or none does. */
+export type TouchPoint = Point & {
+    t?: number;
+};
+/** One finger: down at the first point, through the rest, up at the last. All fingers go down and lift together. */
+export type TouchPath = {
+    points: readonly TouchPoint[];
+};
+export type GestureOptions = {
+    /** untimed paths only: first point to last, each finger at constant speed (by arc length). Default 300. */
+    durationMs?: number;
+    /** fingers still at their first points before moving (press-then-drag). Default 0. */
+    holdMs?: number;
+    /** fingers still at their last points before lifting (no fling). Default 0. */
+    releaseMs?: number;
+};
+/**
+ * `radius`: finger distance from the centre (default 100 pt on iOS, 100 x screen scale px on Android);
+ * `angle`: the finger axis in degrees, 0 = horizontal.
+ */
+export type TwoFingerOptions = {
+    durationMs?: number;
+    radius?: number;
+    angle?: number;
+};
+export type Role = "button" | "text" | "textfield" | "securefield" | "searchfield" | "image" | "switch" | "checkbox" | "slider" | "link" | "cell" | "list" | "scrollview" | "tab" | "tabbar" | "alert" | "sheet" | "keyboard" | "navbar" | "toolbar" | "window" | "application" | "other";
+/** One accessibility node, normalized across iOS (axbridge / ax) and Android (uiautomator). */
+export type Element = {
+    /** driver-local stable id for this snapshot (preorder path such as `0.3.1`, or the backend's unique id) */
+    id: string;
+    role: Role;
+    /** iOS XCUI type (`Button`) or Android class (`android.widget.EditText`) */
+    rawType: string;
+    /** AX label / content-desc */
+    label?: string;
+    /** RN testID: iOS accessibilityIdentifier / Android resource-id without the package prefix */
+    identifier?: string;
+    /** AX value / Android text of inputs */
+    value?: string;
+    /** Android text; iOS: label of static text */
+    text?: string;
+    placeholder?: string;
+    frame: Rect;
+    /** `frame` as 0–1 fractions of the screen */
+    normFrame: Rect;
+    /** iOS decoded traits; Android flags (clickable, checkable, scrollable, …) */
+    traits: string[];
+    enabled: boolean;
+    focused?: boolean;
+    hidden?: boolean;
+    selected?: boolean;
+    checked?: boolean;
+    /** only when reachability was requested (iOS ~18 ms per element) or derivable (Android) */
+    hittable?: boolean;
+    /** where to tap: iOS `interactable.actionable.at`, else the frame centre */
+    tapPoint?: Point;
+    pid?: number;
+    depth: number;
+    children: Element[];
+};
+export type SnapshotBackend = "axbridge" | "ax" | "uiautomator";
+export type ScreenInfo = {
+    width: number;
+    height: number;
+    scale: number;
+    rotation?: number;
+};
+export type ModalInfo = {
+    pid?: number;
+    description?: string;
+};
+export type Snapshot = {
+    platform: Platform;
+    backend: SnapshotBackend;
+    takenAt: number;
+    screen: ScreenInfo;
+    /** the tree */
+    elements: Element[];
+    /** the same nodes in preorder (reading order is derived by consumers) */
+    flat: Element[];
+    truncated: boolean;
+    modal?: ModalInfo;
+};
+export type Orientation = "portrait" | "portraitUpsideDown" | "landscapeLeft" | "landscapeRight";
+export type HardwareButton = "home" | "back" | "lock" | "volumeUp" | "volumeDown" | "shake";
+export type KeyName = "Enter" | "Backspace" | "Tab" | "Space" | "Escape" | "Delete" | "Up" | "Down" | "Left" | "Right";
+export type Modifier = "shift" | "cmd" | "alt" | "ctrl";
+export type AlertInfo = {
+    title?: string;
+    message?: string;
+    buttons: Element[];
+};
+export type HealthInfo = {
+    platform: Platform;
+    id: string;
+    version: string;
+    /** iOS: negotiated HID transport; Android: `adb` */
+    transport: string;
+    /** iOS: `axbridge` availability */
+    bridge?: "available" | "missing" | "failed";
+    screen: ScreenInfo;
+    detail?: Record<string, unknown>;
+};
+export type LaunchOptions = {
+    /** extra launch arguments (iOS: after the bundle id; Android: intent extras are not supported in v1) */
+    args?: readonly string[];
+    env?: Record<string, string>;
+    /** iOS: `--terminate-running-process`; Android: `am force-stop` first. Default true. */
+    relaunch?: boolean;
+};
+export type DriverCapabilities = {
+    /** two-finger `pinch` and `rotate` */
+    pinch: boolean;
+    /** most fingers `gesture` takes: 2 multi-touch, 1 single-finger paths only, 0 no `gesture` */
+    maxPointers: 0 | 1 | 2;
+    unicodeText: boolean;
+    nativeSettle: boolean;
+    alerts: boolean;
+    reachability: boolean;
+    /**
+     * `elementAtPoint` costs far less than a whole `snapshot` (iOS: one AX hit-test, ~10 ms, against ~76 ms), so a tap
+     * may check the snapshot an assertion just kept with one hit-test instead of taking another. Absent = no (Android's
+     * hit-test is a whole snapshot).
+     */
+    cheapHitTest?: boolean;
+};
+export type AppCommands = {
+    launch(bundleId: string, opts?: LaunchOptions): DriverResult<void>;
+    terminate(bundleId: string): DriverResult<void>;
+    openUrl(url: string): DriverResult<void>;
+    install(path: string): DriverResult<void>;
+    uninstall(bundleId: string): DriverResult<void>;
+    isInstalled(bundleId: string): DriverResult<boolean>;
+    isRunning(bundleId: string): DriverResult<boolean>;
+    /** wipe app data, keep the build (iOS: core `resetAppData`; Android: `pm clear`) */
+    clearData(bundleId: string, opts?: {
+        keychain?: boolean;
+    }): DriverResult<void>;
+};
+export interface Driver {
+    readonly platform: Platform;
+    /** udid (iOS) or serial (Android) */
+    readonly id: string;
+    readonly capabilities: DriverCapabilities;
+    health(): DriverResult<HealthInfo>;
+    snapshot(opts?: {
+        interactiveOnly?: boolean;
+        backend?: SnapshotBackend;
+    }): DriverResult<Snapshot>;
+    elementAtPoint(point: Point, opts?: {
+        reachability?: boolean;
+    }): DriverResult<Element | null>;
+    tap(point: Point, opts?: {
+        count?: number;
+        durationMs?: number;
+    }): DriverResult<void>;
+    longPress(point: Point, opts?: {
+        durationMs?: number;
+    }): DriverResult<void>;
+    swipe(from: Point, to: Point, opts?: {
+        durationMs?: number;
+        momentum?: boolean;
+    }): DriverResult<void>;
+    drag(from: Point, to: Point, opts?: {
+        pressMs?: number;
+        durationMs?: number;
+        releaseMs?: number;
+    }): DriverResult<void>;
+    /** Two fingers around `center` spread (`scale` > 1) or close (< 1). */
+    pinch(center: Point, scale: number, opts?: TwoFingerOptions): DriverResult<void>;
+    /** Two fingers turn `degrees` around `center`; positive is clockwise on screen. */
+    rotate(center: Point, degrees: number, opts?: TwoFingerOptions): DriverResult<void>;
+    /** 1-2 finger paths on one timeline (`driver/gesture-geometry.ts`); fingers go down and lift together. */
+    gesture(paths: readonly TouchPath[], opts?: GestureOptions): DriverResult<void>;
+    /** iOS: HID keyboard → paste fallback for non-ASCII; Android: `input text` (ASCII only) */
+    typeText(text: string): DriverResult<void>;
+    key(key: KeyName, modifiers?: readonly Modifier[]): DriverResult<void>;
+    pressButton(button: HardwareButton): DriverResult<void>;
+    screenshot(opts?: {
+        path?: string;
+        scale?: number;
+    }): DriverResult<{
+        path?: string;
+        png?: Uint8Array;
+    }>;
+    orientation(set?: Orientation): DriverResult<Orientation>;
+    /** wait for a quiet UI: iOS axbridge quiescence, else snapshot-hash polling */
+    settle(opts?: {
+        quietMs?: number;
+        timeoutMs?: number;
+    }): DriverResult<{
+        quiet: boolean;
+        waitedMs: number;
+    }>;
+    /** the system alert / sheet on top, if any */
+    alert(): DriverResult<AlertInfo | null>;
+    appearance(set?: "light" | "dark"): DriverResult<"light" | "dark">;
+    clipboard(set?: string): DriverResult<string>;
+    readonly app: AppCommands;
+    close(): Promise<void>;
+}
+export type Logger = (line: string) => void;

package/types/e2e/src/driver/errors.d.ts

@@ -0,0 +1,13 @@
+import type { ErrorResult } from "../../../types/src/result";
+import type { DriverError, DriverErrorCode } from "./driver.types";
+export declare function driverError(code: DriverErrorCode, message: string, extra?: {
+    retryable?: boolean;
+    detail?: unknown;
+}): DriverError;
+/** `err()` for `DriverResult`. */
+export declare function driverErr(code: DriverErrorCode, message: string, extra?: {
+    retryable?: boolean;
+    detail?: unknown;
+}): ErrorResult<DriverError>;
+/** One line for logs and CLI output. */
+export declare function describeDriverError(error: DriverError): string;