@ishlabs/cli 0.25.0 → 0.26.0

package/dist/lib/local-sim/ios.js

@@ -1,14 +1,15 @@
 /**
- * IOSDevice — drives a local iOS simulator via `xcrun simctl` + `idb`,
+ * IOSDevice — drives a local iOS simulator via `xcrun simctl` (lifecycle +
+ * screenshot) and WebDriverAgent/XCUITest (UI + a11y; see xcuitest.ts),
  * implementing the SimulationDevice surface the loop expects. Mirrors
  * AndroidDevice; the one substantive difference is the coordinate space.
  *
  * Two resolution paths, mirroring the browser:
- *  - ELEMENT (preferred): observe() reads the `idb ui describe-all` a11y tree,
- *    serializes it to the `[id] role "label"` string the backend DOMLocator
- *    reasons over, and keeps a local `shortId → bounds` map (bounds in POINTS).
- *    The backend returns a `node_id`; executeAction() looks the bounds up and
- *    taps the element's CENTER.
+ *  - ELEMENT (preferred): observe() reads WDA's `/source` a11y tree, serializes
+ *    it to the `[id] role "label"` string the backend DOMLocator reasons over,
+ *    and keeps a local `shortId → bounds` map (bounds in POINTS). The backend
+ *    returns a `node_id`; executeAction() looks the bounds up and taps the
+ *    element's CENTER.
  *  - VISION (fallback): when the tree is empty/sparse, observe() returns an
  *    empty tree so the backend takes its vision branch and returns NORMALIZED
  *    0-1000 coordinates. Also taken per-action whenever node_id is absent.
@@ -16,7 +17,7 @@
  * COORDINATE SPACE — two spaces, the key difference from Android (where
  * screencap and tap share one pixel space):
  *   `simctl io booted screenshot` is in PIXELS (e.g. 1179x2556 @3x), but
- *   `idb ui tap/swipe` AND the `describe-all` a11y frames are POINTS (393x852).
+ *   WDA taps/swipes AND the `/source` a11y frames are POINTS (393x852).
  *   The invariant in BOTH paths: TAP in points, RECORD in pixels, because the
  *   loop re-normalizes the recorded coord against dimensions() (PIXELS).
  *     - VISION:  tap pt = round(n/1000 * pointSize); record px = round(n/1000 * pixelSize).
@@ -30,10 +31,12 @@
  *   backend never converts coords with screen_width/height.
  */
 import { resolveTextValue } from "./actions.js";
-import { requireOneBootedSimulator, describeScreen, describeAll, screenshotPng, uiTap, uiLongPress, uiSwipe, uiText, uiKey, HID_KEY_RETURN, terminateApp, launchApp, installApp, isAppInstalled, bundleIdFromApp, } from "./simctl.js";
+import { requireOneBootedSimulator, screenshotPng, terminateApp, launchApp, installApp, isAppInstalled, bundleIdFromApp, } from "./simctl.js";
+// iOS UI interaction + a11y run through WebDriverAgent (XCUITest), not idb.
+import { ensureWda, closeWda, describeScreen, describeAll, uiTap, uiLongPress, uiSwipe, uiText, uiKey, HID_KEY_RETURN, } from "./xcuitest.js";
 import { isLocalPath } from "../upload.js";
 import { deNormalizePoint, deNormalizeDrag, pointToPixel } from "./coordinates.js";
-import { parseIdbDescribeAll, serializeNativeTree, boundsCenter } from "./native-a11y.js";
+import { parseXcuiHierarchy, serializeNativeTree, boundsCenter } from "./native-a11y.js";
 // Let animations/transitions settle before the next observation so the
 // screenshot the LLM reasons over reflects the action's result.
 const POST_GESTURE_SETTLE_MS = 500;
@@ -61,6 +64,8 @@ export class IOSDevice {
     appPath;
     /** udid of the single booted simulator we drive. */
     udid = "";
+    /** Set once the WebDriverAgent runner is up, so the startup note logs once. */
+    wdaStarted = false;
     /** POINT size — what idb ui tap/swipe consume (de-normalization basis for TAPS). */
     pointWidth = 0;
     pointHeight = 0;
@@ -96,6 +101,14 @@ export class IOSDevice {
             this.bundleId = await this.resolveBundleId(target);
         }
         const bundleId = this.bundleId;
+        // Bring up the WebDriverAgent runner (install + simctl-launch the prebuilt
+        // xctrunner, open a session). Idempotent and reused across participants, so
+        // the ~30-60s first-launch cost is paid once per run.
+        if (!this.wdaStarted) {
+            this.log("Starting the iOS automation runner (WebDriverAgent); first launch can take ~30-60s...");
+        }
+        await ensureWda(this.udid);
+        this.wdaStarted = true;
         // Prime screen geometry (points) before the first de-normalization.
         await this.refreshScreen();
         // Per-participant reset: terminate then relaunch from a clean state.
@@ -171,7 +184,7 @@ export class IOSDevice {
         };
     }
     /**
-     * Read + serialize the idb describe-all a11y tree (bounds in POINTS). Any
+     * Read + serialize WDA's /source a11y tree (bounds in POINTS). Any
      * failure (retries exhausted on a trivial tree, parse error) degrades to an
      * empty tree so the backend falls back to vision — a missing tree must never
      * abort the observation.
@@ -179,7 +192,7 @@ export class IOSDevice {
     async dumpTree() {
         try {
             const json = await describeAll(this.udid);
-            const nodes = parseIdbDescribeAll(json);
+            const nodes = parseXcuiHierarchy(json);
             const tree = serializeNativeTree(nodes);
             this.log(`a11y tree: ${tree.nodeMap.size} node(s)`);
             return tree;
@@ -206,7 +219,7 @@ export class IOSDevice {
         // separately in points (see toPoints()).
         return { width: this.pixelWidth, height: this.pixelHeight };
     }
-    /** Normalized 0-1000 → POINT space (idb ui tap/swipe take points). */
+    /** Normalized 0-1000 → POINT space (WDA taps/swipes take points). */
     toPoints(c) {
         return deNormalizePoint(c, this.pointWidth, this.pointHeight);
     }
@@ -227,7 +240,7 @@ export class IOSDevice {
             const bounds = this.lastNodeMap.get(action.node_id);
             if (!bounds)
                 return { pt: null, px: null, stale: true };
-            const pt = boundsCenter(bounds); // POINTS — idb taps directly
+            const pt = boundsCenter(bounds); // POINTS — WDA taps directly
             const px = pointToPixel(pt, this.pointWidth, this.pointHeight, this.pixelWidth, this.pixelHeight);
             return { pt, px, stale: false };
         }
@@ -237,7 +250,7 @@ export class IOSDevice {
     }
     async executeAction(action) {
         try {
-            // pt drives the idb TAP (points); px is what we RECORD (pixels). ELEMENT
+            // pt drives the WDA TAP (points); px is what we RECORD (pixels). ELEMENT
             // path: pt = bounds-center, px = that center scaled to pixels. VISION
             // path: both derive from the same normalized coord. Either way the tap
             // lands right and the recorded px round-trips against dimensions().
@@ -279,6 +292,11 @@ export class IOSDevice {
                     await this.navigateBack();
                     break;
                 }
+                case "open_system_panel": {
+                    // Element-less, like navigate_back: best-effort top-edge pull-down.
+                    await this.openSystemPanel(action.panel === "quick_settings" ? "quick_settings" : "notifications");
+                    break;
+                }
                 case "drag": {
                     // A drag GRABS an element and RELEASES it elsewhere ("click the
                     // element, move, let go") — distinct from a swipe (element-less
@@ -364,7 +382,7 @@ export class IOSDevice {
             await settle(250);
         }
         const text = resolveTextValue(action, this.contextValues);
-        // idb ui text appends to the focused field; for click_type (replace) there
+        // WDA text input appends to the focused field; for click_type (replace) there
         // is no idb "clear", so we rely on the field being empty after focus. The
         // vision agent typically taps an empty field, so this matches Android's
         // common path; a true select-all clear isn't exposed by idb.
@@ -470,10 +488,10 @@ export class IOSDevice {
      * do drive the system gesture) when no back button is visible.
      */
     async navigateBack() {
-        const nodes = parseIdbDescribeAll(await describeAll(this.udid));
+        const nodes = parseXcuiHierarchy(await describeAll(this.udid));
         const back = this.findBackButton(nodes);
         if (back) {
-            const c = boundsCenter(back.bounds); // POINTS — idb taps directly
+            const c = boundsCenter(back.bounds); // POINTS — WDA taps directly
             await uiTap(this.udid, c.x, c.y);
             return;
         }
@@ -483,6 +501,39 @@ export class IOSDevice {
         const midY = Math.round(this.pointHeight / 2);
         await uiSwipe(this.udid, 1, midY, Math.round(this.pointWidth * 0.5), midY, 300);
     }
+    /**
+     * Best-effort open of an iOS system panel by swiping down from the top edge.
+     * iOS has no `cmd statusbar` equivalent, so on a Face-ID layout:
+     *   - notifications → Notification Center: swipe down from the top-CENTER.
+     *   - quick_settings → Control Center: swipe down from the top-RIGHT corner.
+     * Coordinates are POINTS (idb consumes points; see toPoints()/the swipe()
+     * helper). This is FLAKY on the simulator — idb's synthetic touch frequently
+     * doesn't trigger the system edge gesture (the same limitation navigateBack's
+     * edge-swipe hits). We compare a before/after screenshot and log LOUDLY when
+     * the screen didn't change, rather than silently reporting success, so a
+     * no-op is visible in the run. The executeAction caller still returns
+     * success:true (the gesture was attempted); the loud log is the signal.
+     */
+    async openSystemPanel(panel) {
+        const before = await screenshotPng();
+        const w = this.pointWidth;
+        const h = this.pointHeight;
+        // Start ON the top edge and travel a third of the screen down. Control
+        // Center lives under the top-right (battery/status) corner on Face-ID
+        // devices; Notification Center under the top-center notch area.
+        const startX = panel === "quick_settings" ? Math.round(w * 0.92) : Math.round(w * 0.5);
+        const startY = 1;
+        const endY = Math.round(h * 0.35);
+        await uiSwipe(this.udid, startX, startY, startX, endY, 350);
+        await settle();
+        // Loudly surface a no-op: the simulator's synthetic touch often can't drive
+        // the system edge gesture. An identical screenshot means the panel didn't open.
+        const after = await screenshotPng();
+        if (before.equals(after)) {
+            this.log(`open_system_panel (${panel}): top-edge swipe produced no visible change — ` +
+                `the simulator's synthetic touch likely didn't trigger the system gesture (flaky on the simulator).`);
+        }
+    }
     /**
      * The nav-bar back button: the leading (leftmost) actionable button in the
      * top nav-bar band. iOS HIG guarantees "back" is the leading nav item in a
@@ -526,7 +577,7 @@ export class IOSDevice {
         // the agent can adapt.
         const hint = {
             pinch_zoom: "no multi-touch on the native driver; the agent should zoom via double_tap",
-            rotate_device: "idb exposes no clean rotate; leave orientation as-is",
+            rotate_device: "rotation is not wired on the native driver; leave orientation as-is",
             keyboard_shortcut: "no hardware keyboard on the native driver; use on-screen taps/text_input",
             switch_tab: "tabs are a browser concept; the native app has a single window",
             close_tab: "tabs are a browser concept; the native app has a single window",
@@ -540,7 +591,9 @@ export class IOSDevice {
         return "";
     }
     async close() {
-        // Leave the app installed/running; the simulator is shared and the next run
-        // resets via launchOrReset. Nothing to tear down (no IME state on iOS).
+        // Tear down the WebDriverAgent session (the runner is left installed on the
+        // shared simulator for the next run). The app resets via launchOrReset; no
+        // IME state to restore on iOS.
+        await closeWda(this.udid);
     }
 }

package/dist/lib/local-sim/loop.js

@@ -49,6 +49,7 @@ export function flattenAction(raw, nodeId = null, nodeDescription = null) {
         key: a.key ?? null,
         tab_id: a.tab_id ?? null,
         orientation: a.orientation ?? null,
+        panel: a.panel ?? null,
         scale: a.scale ?? null,
         // Native path: ResolvedAction.coordinates (top level of the resolved_actions
         // entry) is the single {x,y} execution point. Fall back to the nested action
@@ -431,6 +432,7 @@ async function runSingleSimulation(client, participantId, participantName, opts,
                                 ...(action.key && { key: action.key }),
                                 ...(action.tab_id && { tab_id: action.tab_id }),
                                 ...(action.orientation && { orientation: action.orientation }),
+                                ...(action.panel && { panel: action.panel }),
                                 // The recorded `coordinates` is the drag START; persist the END
                                 // (normalized 0-1000) too so the journey captures the full path.
                                 ...(action.drag && { drag_end: { x: action.drag.endX, y: action.drag.endY } }),

package/dist/lib/local-sim/native-a11y.d.ts

@@ -12,7 +12,7 @@
  *
  * COORDINATE SPACE — carried, not converted, by this module:
  *   - Android `uiautomator dump` bounds are screencap PIXELS (`space: "px"`).
- *   - iOS `idb ui describe-all` frames are POINTS (`space: "points"`).
+ *   - iOS WebDriverAgent /source frames are POINTS (`space: "points"`).
  * The device de-normalizes/taps in its own space (AndroidDevice taps pixels;
  * IOSDevice taps points), so the `space` tag tells the caller which dimension a
  * node's bounds-center belongs to. This module never mixes the two.
@@ -65,15 +65,29 @@ export interface NativeTree {
  */
 export declare function parseUiautomatorXml(xml: string): NativeNode[];
 /**
- * Parse `idb ui describe-all` JSON (a FLAT array of elements, each with a `frame`
- * in POINTS) into NativeNodes in array order. iOS is already a flat,
- * properly-labeled list — no ancestor walk needed — so `clickable` is derived
- * from the element's role/type and whether it carries a usable label.
+ * Parse WDA's `GET /source?format=json` — a NESTED accessibility tree — into the
+ * FLAT, depth-first `NativeNode[]` (POINTS) that `parseXcuiHierarchy` produces,
+ * so `serializeNativeTree` consumes it unchanged. WDA's `type` matches idb's iOS
+ * types (Button/StaticText/SearchField/Cell/Image/Application…), so
+ * `normalizeRole`/`IOS_ACTIONABLE_TYPES`/`frameToBounds` all apply as-is.
+ *
+ * KEY: WDA's `/source` is the FULL XCUIElement tree — every container and leaf —
+ * NOT idb's clean accessibility-elements list. iOS settings rows surface as an
+ * accessible `Button` ("General", isAccessible=1) that ALSO contains a duplicate
+ * inner `StaticText` ("General", isAccessible=0) and is wrapped in a `Cell`
+ * (isAccessible=0). Emitting all three yields "General General" + empty
+ * listitems. So we emit ONLY `isAccessible && isVisible` nodes — exactly the
+ * VoiceOver-exposed set idb returned: the labeled Button is both the label and
+ * the tap target; the duplicate StaticText and the wrapping Cell are pruned. A
+ * sparse a11y tree degrades to the loop's vision fallback, so strict filtering
+ * never strands the run.
+ *
+ * Accepts either the raw tree or the W3C `{ value: <tree> }` envelope WDA returns.
  */
-export declare function parseIdbDescribeAll(json: string): NativeNode[];
+export declare function parseXcuiHierarchy(json: string): NativeNode[];
 /**
  * Serialize a flat NativeNode list (from `parseUiautomatorXml` /
- * `parseIdbDescribeAll`) into the `[id] role "label"` string the DOMLocator
+ * `parseXcuiHierarchy`) into the `[id] role "label"` string the DOMLocator
  * reasons over, plus a `shortId → bounds` map for local tap resolution.
  *
  * Emission rules (kept tight, like the DOM serializer):

package/dist/lib/local-sim/native-a11y.js

@@ -12,7 +12,7 @@
  *
  * COORDINATE SPACE — carried, not converted, by this module:
  *   - Android `uiautomator dump` bounds are screencap PIXELS (`space: "px"`).
- *   - iOS `idb ui describe-all` frames are POINTS (`space: "points"`).
+ *   - iOS WebDriverAgent /source frames are POINTS (`space: "points"`).
  * The device de-normalizes/taps in its own space (AndroidDevice taps pixels;
  * IOSDevice taps points), so the `space` tag tells the caller which dimension a
  * node's bounds-center belongs to. This module never mixes the two.
@@ -50,7 +50,7 @@ const ROLE_NORMALIZATION = {
     ScrollView: "generic",
     RecyclerView: "list",
     ListView: "list",
-    // iOS (idb `type`, AX-prefixed `role` handled by stripAxPrefix below).
+    // iOS (WDA / XCUITest `type`, AX-prefixed `role` handled by stripAxPrefix below).
     StaticText: "text",
     TextField: "textbox",
     SecureTextField: "textbox",
@@ -181,6 +181,9 @@ function buildAndroidTree(xml) {
 function makeRawAndroidNode(role, text, contentDesc, resourceId, clickable, bounds) {
     return { role, text, contentDesc, resourceId, clickable, bounds, children: [] };
 }
+// ---------------------------------------------------------------------------
+// iOS — shared helpers for the WebDriverAgent (XCUITest) /source parser below
+// ---------------------------------------------------------------------------
 /** iOS roles/types that are directly actionable (the device taps their center). */
 const IOS_ACTIONABLE_TYPES = new Set([
     "Button",
@@ -195,50 +198,7 @@ const IOS_ACTIONABLE_TYPES = new Set([
     "MenuItem",
     "Tab",
 ]);
-/**
- * Parse `idb ui describe-all` JSON (a FLAT array of elements, each with a `frame`
- * in POINTS) into NativeNodes in array order. iOS is already a flat,
- * properly-labeled list — no ancestor walk needed — so `clickable` is derived
- * from the element's role/type and whether it carries a usable label.
- */
-export function parseIdbDescribeAll(json) {
-    let parsed;
-    try {
-        parsed = JSON.parse(json);
-    }
-    catch {
-        return [];
-    }
-    if (!Array.isArray(parsed))
-        return [];
-    const out = [];
-    for (const raw of parsed) {
-        const bounds = idbFrameToBounds(raw.frame);
-        if (!bounds)
-            continue; // malformed / zero-area frame → no tappable center
-        // Label: prefer the spoken AXLabel; fall back to AXValue (search fields
-        // expose their placeholder as AXValue, e.g. "Search"). AXValue is only a
-        // STRING fallback — switches/sliders/steppers report it as a number/boolean
-        // (a Switch is 1/0), and `.trim()` on those would throw and lose the whole
-        // tree to a silent vision fallback. An unlabeled toggle then emits as a bare
-        // `[id] switch` (still tappable via its frame center).
-        const label = (raw.AXLabel ?? (typeof raw.AXValue === "string" ? raw.AXValue : "")).trim();
-        const rawType = raw.type ?? (raw.role ? stripAxPrefix(raw.role) : "");
-        const typeKey = stripAxPrefix(rawType);
-        const actionable = IOS_ACTIONABLE_TYPES.has(typeKey) && raw.enabled !== false;
-        out.push({
-            role: normalizeRole(rawType),
-            label,
-            bounds,
-            clickable: actionable,
-            hasOwnLabel: label.length > 0,
-            resourceId: raw.AXUniqueId ?? undefined,
-            space: "points",
-        });
-    }
-    return out;
-}
-function idbFrameToBounds(frame) {
+function frameToBounds(frame) {
     if (!frame)
         return null;
     const { x, y, width, height } = frame;
@@ -254,6 +214,81 @@ function idbFrameToBounds(frame) {
     }
     return { x, y, width, height };
 }
+/** WDA's "1"/"0" (or real boolean) → boolean. */
+function wdaTruthy(v) {
+    return v === true || v === "1";
+}
+/**
+ * Parse WDA's `GET /source?format=json` — a NESTED accessibility tree — into the
+ * FLAT, depth-first `NativeNode[]` (POINTS) that `parseXcuiHierarchy` produces,
+ * so `serializeNativeTree` consumes it unchanged. WDA's `type` matches idb's iOS
+ * types (Button/StaticText/SearchField/Cell/Image/Application…), so
+ * `normalizeRole`/`IOS_ACTIONABLE_TYPES`/`frameToBounds` all apply as-is.
+ *
+ * KEY: WDA's `/source` is the FULL XCUIElement tree — every container and leaf —
+ * NOT idb's clean accessibility-elements list. iOS settings rows surface as an
+ * accessible `Button` ("General", isAccessible=1) that ALSO contains a duplicate
+ * inner `StaticText` ("General", isAccessible=0) and is wrapped in a `Cell`
+ * (isAccessible=0). Emitting all three yields "General General" + empty
+ * listitems. So we emit ONLY `isAccessible && isVisible` nodes — exactly the
+ * VoiceOver-exposed set idb returned: the labeled Button is both the label and
+ * the tap target; the duplicate StaticText and the wrapping Cell are pruned. A
+ * sparse a11y tree degrades to the loop's vision fallback, so strict filtering
+ * never strands the run.
+ *
+ * Accepts either the raw tree or the W3C `{ value: <tree> }` envelope WDA returns.
+ */
+export function parseXcuiHierarchy(json) {
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch {
+        return [];
+    }
+    // WDA returns the tree under a W3C `{ value: <tree>, sessionId }` envelope, but
+    // a raw tree NODE also has its own `value` field (the element's value) — so we
+    // can't unwrap on `"value" in parsed` alone. The actual tree root is the one
+    // carrying a node-shaped `type`; only unwrap `value` when the top level is NOT
+    // itself a node.
+    const obj = parsed;
+    const root = obj && typeof obj === "object" && !("type" in obj) && "value" in obj
+        ? obj.value
+        : obj;
+    if (!root || typeof root !== "object")
+        return [];
+    const out = [];
+    const visit = (n) => {
+        const bounds = frameToBounds(n.rect ?? undefined);
+        if (bounds && wdaTruthy(n.isAccessible) && wdaTruthy(n.isVisible)) {
+            // Prefer the spoken label; fall back to a STRING value (search fields
+            // expose their placeholder as `value`). Non-string values (a Switch's 1/0)
+            // are ignored for the label, exactly like the idb path.
+            const label = (n.label ?? (typeof n.value === "string" ? n.value : "")).trim();
+            const rawType = n.type ?? "";
+            const typeKey = stripAxPrefix(rawType);
+            // `isEnabled` absent ⇒ assume enabled (WDA omits it on always-enabled types).
+            const enabled = n.isEnabled == null ? true : wdaTruthy(n.isEnabled);
+            const actionable = IOS_ACTIONABLE_TYPES.has(typeKey) && enabled;
+            out.push({
+                role: normalizeRole(rawType),
+                label,
+                bounds,
+                clickable: actionable,
+                hasOwnLabel: label.length > 0,
+                resourceId: (n.name || n.rawIdentifier) ?? undefined,
+                space: "points",
+            });
+        }
+        // Recurse into ALL children — an accessible element can nest inside a
+        // non-accessible container (the Cell wrapping the Button), so we must not
+        // prune the walk by accessibility, only the emission.
+        for (const c of n.children ?? [])
+            visit(c);
+    };
+    visit(root);
+    return out;
+}
 // ---------------------------------------------------------------------------
 // Serialization — flat NativeNode list → `[id] role "label"` + nodeMap
 // ---------------------------------------------------------------------------
@@ -271,7 +306,7 @@ function normalizeLabel(label) {
 }
 /**
  * Serialize a flat NativeNode list (from `parseUiautomatorXml` /
- * `parseIdbDescribeAll`) into the `[id] role "label"` string the DOMLocator
+ * `parseXcuiHierarchy`) into the `[id] role "label"` string the DOMLocator
  * reasons over, plus a `shortId → bounds` map for local tap resolution.
  *
  * Emission rules (kept tight, like the DOM serializer):

package/dist/lib/local-sim/simctl.d.ts

@@ -1,38 +1,34 @@
 /**
- * Thin async wrappers over `xcrun simctl` + `idb` for the native-iOS sim path.
+ * Thin async wrappers over `xcrun simctl` for the native-iOS sim path: simulator
+ * LIFECYCLE (boot detection, install, terminate, launch) and the SCREENSHOT.
  *
- * Two tools, two jobs:
- *  - `xcrun simctl` drives the simulator LIFECYCLE (boot detection, install,
- *    terminate, launch) and the SCREENSHOT.
- *  - `idb` drives UI INPUT (tap/swipe/text/key) and reports the screen
- *    geometry (pixels, points, and the scale between them).
+ * UI interaction + the accessibility tree live in `xcuitest.ts` (WebDriverAgent),
+ * NOT here — iOS no longer depends on idb.
  *
  * COORDINATE SPACES (the key difference from Android, where screencap and tap
  * share one pixel space):
  *  - `simctl io booted screenshot` writes a PNG in PIXELS (e.g. 1179x2556 @3x).
- *  - `idb ui tap/swipe` take POINTS (e.g. 393x852) — pixels / scale.
- * The native sim TAPS in points (de-normalize 0-1000 against the POINT size)
- * but RECORDS in PIXELS: dimensions() returns the pixel size so the loop's
- * round-trip is exact. Recording in points would drift — the point grid (393)
- * is coarser than the 0-1000 normalized grid, so it double-rounds. See
- * IOSDevice for the full derivation.
+ *  - WebDriverAgent's taps/swipes + a11y frames are POINTS (e.g. 393x852).
+ * The native sim TAPS in points (de-normalize 0-1000 against the POINT size) but
+ * RECORDS in PIXELS: dimensions() returns the pixel size so the loop's round-trip
+ * is exact. Recording in points would drift — the point grid (393) is coarser
+ * than the 0-1000 normalized grid, so it double-rounds. See IOSDevice.
  */
 export declare class IosError extends Error {
     constructor(message: string);
 }
 /** Run `xcrun simctl <args>` and return trimmed stdout. */
 export declare function simctl(args: string[], timeoutMs?: number): Promise<string>;
-/** Run `idb <args>` and return trimmed stdout. */
-export declare function idb(args: string[], timeoutMs?: number): Promise<string>;
 /**
  * Assert exactly one simulator is Booted and return its udid. We pin every
- * subsequent idb/simctl call (and the screenshot) to "booted", so multiple
+ * subsequent simctl/WDA call (and the screenshot) to "booted", so multiple
  * booted simulators are ambiguous and rejected.
  */
 export declare function requireOneBootedSimulator(): Promise<string>;
 /**
- * Screen geometry from `idb describe --json`: PIXEL size, POINT size, and the
- * scale (`density`) between them. Points drive idb ui tap/swipe; pixels are the
+ * Screen geometry: PIXEL size, POINT size, and the scale (`density`) between
+ * them. Produced by the XCUITest driver's `describeScreen` (xcuitest.ts) and
+ * consumed by IOSDevice — points drive WDA taps/swipes; pixels are the
  * screenshot's resolution.
  */
 export interface IosScreen {
@@ -42,38 +38,12 @@ export interface IosScreen {
     pointHeight: number;
     density: number;
 }
-export declare function describeScreen(udid: string): Promise<IosScreen>;
 /**
  * Capture the booted simulator's screen as PNG bytes via
  * `simctl io booted screenshot`. simctl writes to a file path (no reliable
  * stdout in current Xcode), so we round-trip through a temp file.
  */
 export declare function screenshotPng(): Promise<Buffer>;
-export declare function uiTap(udid: string, x: number, y: number): Promise<void>;
-export declare function uiLongPress(udid: string, x: number, y: number, durationMs?: number): Promise<void>;
-export declare function uiSwipe(udid: string, x1: number, y1: number, x2: number, y2: number, durationMs?: number): Promise<void>;
-/**
- * Type text into the focused field. Unlike Android's `adb shell input text`,
- * `idb ui text` handles spaces/unicode/quotes correctly, so no helper IME is
- * needed.
- */
-export declare function uiText(udid: string, text: string): Promise<void>;
-/**
- * Press a hardware key by HID usage code. `idb ui key 40` is Return/Enter
- * (used to submit a text field).
- */
-export declare function uiKey(udid: string, keycode: number): Promise<void>;
-/** HID usage code for Return/Enter. */
-export declare const HID_KEY_RETURN = 40;
-/**
- * Capture the current accessibility tree as `idb ui describe-all` JSON (a flat
- * array of elements, each with a POINT frame) and return it. Mirrors the
- * oracle's `ios_describe`: right after a tap the tree can be mid-transition and
- * come back empty/partial, so we retry until we get an array with more than just
- * the root application node. Throws IosError if every attempt yields a trivial
- * tree so the caller can degrade to the vision path.
- */
-export declare function describeAll(udid: string): Promise<string>;
 export declare function terminateApp(udid: string, bundleId: string): Promise<void>;
 export declare function launchApp(udid: string, bundleId: string): Promise<void>;
 export declare function installApp(udid: string, appPath: string): Promise<void>;