@houwert/conductor 0.16.0 → 0.17.0

package/dist/commands/workspace.js

@@ -0,0 +1,162 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HELP = void 0;
+exports.workspaceInfo = workspaceInfo;
+exports.workspaceCmd = workspaceCmd;
+exports.HELP = `  workspace info                       Print detected project type, bundle IDs, devices, Metro port`;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const output_js_1 = require("../output.js");
+const list_devices_js_1 = require("./list-devices.js");
+const metro_discovery_js_1 = require("../drivers/log-sources/metro-discovery.js");
+function findProjectRoot(start) {
+    let cur = path_1.default.resolve(start);
+    for (let i = 0; i < 20; i++) {
+        if (fs_1.default.existsSync(path_1.default.join(cur, 'package.json')))
+            return cur;
+        if (fs_1.default.existsSync(path_1.default.join(cur, '.git')))
+            return cur;
+        const parent = path_1.default.dirname(cur);
+        if (parent === cur)
+            break;
+        cur = parent;
+    }
+    return start;
+}
+function readJson(file) {
+    try {
+        return JSON.parse(fs_1.default.readFileSync(file, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function detectIosBundleId(projectRoot) {
+    const iosDir = path_1.default.join(projectRoot, 'ios');
+    if (!fs_1.default.existsSync(iosDir))
+        return { id: null, name: null };
+    // Look for the first .xcodeproj/project.pbxproj and grep PRODUCT_BUNDLE_IDENTIFIER.
+    try {
+        const entries = fs_1.default.readdirSync(iosDir);
+        const xcodeproj = entries.find((e) => e.endsWith('.xcodeproj'));
+        if (!xcodeproj)
+            return { id: null, name: null };
+        const pbx = path_1.default.join(iosDir, xcodeproj, 'project.pbxproj');
+        if (!fs_1.default.existsSync(pbx))
+            return { id: null, name: xcodeproj.replace('.xcodeproj', '') };
+        const text = fs_1.default.readFileSync(pbx, 'utf-8');
+        const m = text.match(/PRODUCT_BUNDLE_IDENTIFIER\s*=\s*"?([A-Za-z0-9._-]+)"?\s*;/);
+        return {
+            id: m ? m[1] : null,
+            name: xcodeproj.replace('.xcodeproj', ''),
+        };
+    }
+    catch {
+        return { id: null, name: null };
+    }
+}
+function detectAndroidBundleId(projectRoot) {
+    const candidates = [
+        path_1.default.join(projectRoot, 'android', 'app', 'build.gradle'),
+        path_1.default.join(projectRoot, 'android', 'app', 'build.gradle.kts'),
+    ];
+    for (const file of candidates) {
+        if (!fs_1.default.existsSync(file))
+            continue;
+        try {
+            const text = fs_1.default.readFileSync(file, 'utf-8');
+            const idMatch = text.match(/applicationId\s+["']([A-Za-z0-9._-]+)["']/);
+            if (idMatch) {
+                return { id: idMatch[1], name: idMatch[1].split('.').pop() ?? null };
+            }
+        }
+        catch {
+            // try next
+        }
+    }
+    return { id: null, name: null };
+}
+async function workspaceInfo(opts = {}) {
+    const projectRoot = findProjectRoot(process.cwd());
+    const pkgPath = path_1.default.join(projectRoot, 'package.json');
+    const pkg = fs_1.default.existsSync(pkgPath) ? readJson(pkgPath) : null;
+    const deps = {
+        ...(pkg?.dependencies ?? {}),
+        ...(pkg?.devDependencies ?? {}),
+    };
+    const rnVersion = deps['react-native'] ?? null;
+    const expoVersion = deps['expo'] ?? null;
+    const hasIosDir = fs_1.default.existsSync(path_1.default.join(projectRoot, 'ios'));
+    const hasAndroidDir = fs_1.default.existsSync(path_1.default.join(projectRoot, 'android'));
+    const hasPlaywright = fs_1.default.existsSync(path_1.default.join(projectRoot, 'playwright.config.ts')) ||
+        fs_1.default.existsSync(path_1.default.join(projectRoot, 'playwright.config.js')) ||
+        fs_1.default.existsSync(path_1.default.join(projectRoot, 'playwright.config.mjs'));
+    let projectType = 'unknown';
+    if (expoVersion)
+        projectType = 'expo';
+    else if (rnVersion)
+        projectType = 'rn';
+    else if (hasIosDir && hasAndroidDir)
+        projectType = 'mixed';
+    else if (hasIosDir)
+        projectType = 'ios';
+    else if (hasAndroidDir)
+        projectType = 'android';
+    else if (hasPlaywright)
+        projectType = 'web';
+    const ios = detectIosBundleId(projectRoot);
+    const android = detectAndroidBundleId(projectRoot);
+    const devices = await (0, list_devices_js_1.discoverBootedDevices)().catch(() => []);
+    let metroPort = null;
+    for (const d of devices) {
+        if (d.platform !== 'ios' && d.platform !== 'tvos' && d.platform !== 'android')
+            continue;
+        const port = await (0, metro_discovery_js_1.discoverMetroPortForDevice)(d.platform, d.id).catch(() => null);
+        if (port) {
+            metroPort = port;
+            break;
+        }
+    }
+    const info = {
+        projectRoot,
+        projectType,
+        reactNativeVersion: rnVersion,
+        bundleIds: { ios: ios.id, android: android.id },
+        bundleNames: { ios: ios.name, android: android.name },
+        hasIosDir,
+        hasAndroidDir,
+        hasPlaywrightConfig: hasPlaywright,
+        configuredDevices: devices.map((d) => ({ id: d.id, name: d.name, platform: d.platform })),
+        metroPort,
+        currentSession: process.env.CONDUCTOR_DEVICE ?? 'default',
+    };
+    if (opts.json) {
+        (0, output_js_1.printData)(info, opts);
+    }
+    else {
+        const lines = [
+            `projectRoot:        ${info.projectRoot}`,
+            `projectType:        ${info.projectType}`,
+            `reactNativeVersion: ${info.reactNativeVersion ?? '(none)'}`,
+            `iOS bundle id:      ${info.bundleIds.ios ?? '(none)'}`,
+            `Android bundle id:  ${info.bundleIds.android ?? '(none)'}`,
+            `ios/ dir:           ${info.hasIosDir}`,
+            `android/ dir:       ${info.hasAndroidDir}`,
+            `playwright config:  ${info.hasPlaywrightConfig}`,
+            `metroPort:          ${info.metroPort ?? '(not running)'}`,
+            `booted devices:     ${info.configuredDevices.length}`,
+            ...info.configuredDevices.map((d) => `  - ${d.id}  ${d.name} (${d.platform})`),
+        ];
+        console.log(lines.join('\n'));
+    }
+    return 0;
+}
+async function workspaceCmd(sub, opts = {}) {
+    if (sub === 'info' || sub === '')
+        return workspaceInfo(opts);
+    (0, output_js_1.printError)(`Unknown workspace subcommand: ${sub}`, opts);
+    return 1;
+}

package/dist/drivers/android.js

@@ -123,6 +123,15 @@ class AndroidDriver {
     async tap(x, y) {
         await this.call('tap', { x: Math.round(x), y: Math.round(y) });
     }
+    /**
+     * Multi-finger gesture playback. Driver injects multi-pointer MotionEvents
+     * via UiAutomation.injectInputEvent — one pointer per path, resampled to a
+     * shared 16ms grid so all fingers move on the same clock. `dt_ms` is the
+     * delay since this finger's previous step (or initial offset for the first).
+     */
+    async gesturePath(paths, timeoutMs = 35000) {
+        await this.call('gesturePath', { paths }, timeoutMs);
+    }
     async inputText(text) {
         await this.call('inputText', { text });
     }

package/dist/drivers/direct-ios-selector.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simpleIOSSelectorTarget = simpleIOSSelectorTarget;
+exports.makeIOSDirectResolver = makeIOSDirectResolver;
+const verbose_js_1 = require("../verbose.js");
+/** Characters that make a selector value a regex rather than a literal. */
+const REGEX_META = /[.*+?^${}()|[\]\\]/;
+/**
+ * Decide whether `sel` is simple enough to resolve through a direct runner
+ * query. Returns the single text/id/query term, or `null` to force the
+ * snapshot path.
+ *
+ * A selector is eligible only when it carries exactly one of text/id/query,
+ * the value is a plain literal (no regex metacharacters), and there are no
+ * index, relative-position or state constraints — those need the full tree.
+ */
+function simpleIOSSelectorTarget(sel) {
+    if (sel.index !== undefined)
+        return null;
+    if (sel.below || sel.above || sel.leftOf || sel.rightOf || sel.containsChild)
+        return null;
+    if (sel.enabled !== undefined ||
+        sel.checked !== undefined ||
+        sel.focused !== undefined ||
+        sel.selected !== undefined) {
+        return null;
+    }
+    const terms = [];
+    if (sel.text != null)
+        terms.push({ key: 'text', value: sel.text });
+    if (sel.id != null)
+        terms.push({ key: 'id', value: sel.id });
+    if (sel.query != null)
+        terms.push({ key: 'query', value: sel.query });
+    if (terms.length !== 1)
+        return null;
+    const target = terms[0];
+    if (!target.value || REGEX_META.test(target.value))
+        return null;
+    return target;
+}
+/**
+ * Build a fast-path resolver for `sel`, or `undefined` when the selector is
+ * not simple enough. The returned function resolves the element via the
+ * runner; it returns `null` (so the caller falls back to the snapshot path)
+ * when the element is absent or the match is ambiguous, and throws only on a
+ * transport failure.
+ */
+function makeIOSDirectResolver(driver, sel, appIds = []) {
+    const target = simpleIOSSelectorTarget(sel);
+    if (!target)
+        return undefined;
+    return async () => {
+        const result = await driver.queryElement(target.key, target.value, appIds);
+        // matchCount > 1 → ambiguous: let the snapshot matcher apply its
+        // deepest-match / prefer-interactive tie-breaking instead of guessing.
+        if (!result.found || result.matchCount !== 1 || !result.node)
+            return null;
+        const n = result.node;
+        const { X, Y, Width, Height } = n.frame;
+        (0, verbose_js_1.log)(`[iOS] direct query ${target.key}="${target.value}" → ` +
+            `text="${n.label || n.title || n.value || n.placeholderValue || ''}" id="${n.identifier}"`);
+        return {
+            centerX: X + Width / 2,
+            centerY: Y + Height / 2,
+            text: n.label || n.title || n.value || n.placeholderValue || undefined,
+            id: n.identifier || undefined,
+        };
+    };
+}

package/dist/drivers/element-resolver.js

@@ -7,6 +7,9 @@ exports.inspectIOSToText = inspectIOSToText;
 exports.inspectAndroidToText = inspectAndroidToText;
 exports.findWebElement = findWebElement;
 exports.inspectWebToText = inspectWebToText;
+exports.findIOSViewAtPoint = findIOSViewAtPoint;
+exports.findAndroidViewAtPoint = findAndroidViewAtPoint;
+exports.findWebViewAtPoint = findWebViewAtPoint;
 const verbose_js_1 = require("../verbose.js");
 // XCUIElementType rawValues that represent interactive controls.
 // Approximates “prefer clickable” when sorting, since AXElement does not expose clickable.
@@ -590,3 +593,189 @@ function visitWeb(nodes, lines, depth) {
         }
     }
 }
+function iosRectAt(el) {
+    return { x: el.frame.X, y: el.frame.Y, width: el.frame.Width, height: el.frame.Height };
+}
+function iosContains(el, x, y) {
+    const r = iosRectAt(el);
+    return x >= r.x && x < r.x + r.width && y >= r.y && y < r.y + r.height;
+}
+// iOS element types that are typically interactive (XCUIElementType enum values).
+// 9=button, 50=staticText skipped, 49=textField, 65=secureTextField, 14=switch, 38=slider, etc.
+const IOS_TAPPABLE_TYPES = new Set([9, 49, 65, 14, 38, 51, 52, 76, 53, 55, 56, 57]);
+function iosNodeTappable(el) {
+    return el.enabled && IOS_TAPPABLE_TYPES.has(el.elementType);
+}
+function iosSummarize(el) {
+    const parts = [`type=${el.elementType}`];
+    if (el.identifier)
+        parts.push(`id=${el.identifier}`);
+    if (el.label)
+        parts.push(`label="${el.label}"`);
+    if (el.value)
+        parts.push(`value="${String(el.value)}"`);
+    const r = iosRectAt(el);
+    parts.push(`bounds=[${Math.round(r.x)},${Math.round(r.y)}][${Math.round(r.x + r.width)},${Math.round(r.y + r.height)}]`);
+    if (!el.enabled)
+        parts.push('disabled');
+    return parts.join(' ');
+}
+/**
+ * Walk the iOS AX tree depth-first and return the deepest element whose frame
+ * contains (x,y). When `tappableOnly` is true, restrict to elements that look
+ * interactive (button, text field, switch, slider, etc.).
+ */
+function findIOSViewAtPoint(root, x, y, tappableOnly = false) {
+    let best = null;
+    let bestArea = Infinity;
+    function visit(node) {
+        if (!iosContains(node, x, y))
+            return;
+        if (!tappableOnly || iosNodeTappable(node)) {
+            const r = iosRectAt(node);
+            const area = r.width * r.height;
+            if (area <= bestArea) {
+                bestArea = area;
+                best = node;
+            }
+        }
+        if (node.children) {
+            for (const child of node.children)
+                visit(child);
+        }
+    }
+    visit(root);
+    if (!best)
+        return null;
+    const matched = best;
+    return {
+        summary: iosSummarize(matched),
+        rect: iosRectAt(matched),
+        id: matched.identifier || undefined,
+        text: matched.label || matched.value,
+        enabled: matched.enabled,
+        tappable: iosNodeTappable(matched),
+    };
+}
+function androidContains(n, x, y) {
+    return x >= n.bounds.x1 && x < n.bounds.x2 && y >= n.bounds.y1 && y < n.bounds.y2;
+}
+function androidRect(n) {
+    return {
+        x: n.bounds.x1,
+        y: n.bounds.y1,
+        width: n.bounds.x2 - n.bounds.x1,
+        height: n.bounds.y2 - n.bounds.y1,
+    };
+}
+function androidSummarize(n) {
+    const parts = [];
+    if (n.className)
+        parts.push(`class=${n.className}`);
+    if (n.resourceId)
+        parts.push(`id=${n.resourceId}`);
+    if (n.text)
+        parts.push(`text="${n.text}"`);
+    if (n.contentDesc)
+        parts.push(`desc="${n.contentDesc}"`);
+    parts.push(`bounds=[${n.bounds.x1},${n.bounds.y1}][${n.bounds.x2},${n.bounds.y2}]`);
+    if (n.clickable)
+        parts.push('clickable');
+    if (!n.enabled)
+        parts.push('disabled');
+    return parts.join(' ');
+}
+function findAndroidViewAtPoint(xml, x, y, tappableOnly = false) {
+    const nodes = parseAndroidHierarchy(xml);
+    let best = null;
+    let bestArea = Infinity;
+    for (const n of nodes) {
+        if (!androidContains(n, x, y))
+            continue;
+        if (tappableOnly && !n.clickable)
+            continue;
+        const r = androidRect(n);
+        const area = r.width * r.height;
+        if (area <= bestArea) {
+            bestArea = area;
+            best = n;
+        }
+    }
+    if (!best)
+        return null;
+    const matched = best;
+    return {
+        summary: androidSummarize(matched),
+        rect: androidRect(matched),
+        id: matched.resourceId || undefined,
+        text: matched.text || matched.contentDesc || undefined,
+        enabled: matched.enabled,
+        tappable: matched.clickable,
+    };
+}
+const WEB_TAPPABLE_ROLES = new Set([
+    'button',
+    'link',
+    'checkbox',
+    'radio',
+    'menuitem',
+    'tab',
+    'option',
+    'switch',
+    'textbox',
+    'searchbox',
+    'combobox',
+    'slider',
+    'spinbutton',
+]);
+function webRectContains(b, x, y) {
+    return x >= b.x && x < b.x + b.width && y >= b.y && y < b.y + b.height;
+}
+function webNodeTappable(node) {
+    return node.enabled && WEB_TAPPABLE_ROLES.has(node.role);
+}
+function webSummarize(node) {
+    const parts = [`role=${node.role}`];
+    if (node.name)
+        parts.push(`name="${node.name}"`);
+    if (node.ref)
+        parts.push(`ref=${node.ref}`);
+    if (node.bounds) {
+        const b = node.bounds;
+        parts.push(`bounds=[${Math.round(b.x)},${Math.round(b.y)}][${Math.round(b.x + b.width)},${Math.round(b.y + b.height)}]`);
+    }
+    if (!node.enabled)
+        parts.push('disabled');
+    return parts.join(' ');
+}
+function findWebViewAtPoint(hierarchy, x, y, tappableOnly = false) {
+    let best = null;
+    let bestArea = Infinity;
+    function visit(node) {
+        if (node.bounds && webRectContains(node.bounds, x, y)) {
+            if (!tappableOnly || webNodeTappable(node)) {
+                const area = node.bounds.width * node.bounds.height;
+                if (area <= bestArea) {
+                    bestArea = area;
+                    best = node;
+                }
+            }
+        }
+        if (node.children)
+            for (const c of node.children)
+                visit(c);
+    }
+    for (const root of hierarchy.elements)
+        visit(root);
+    if (!best)
+        return null;
+    const matched = best;
+    return {
+        summary: webSummarize(matched),
+        rect: matched.bounds ?? { x: 0, y: 0, width: 0, height: 0 },
+        text: matched.name || undefined,
+        role: matched.role,
+        enabled: matched.enabled,
+        tappable: webNodeTappable(matched),
+    };
+}

package/dist/drivers/flow-recorder.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultRecordingPath = defaultRecordingPath;
+exports.startRecording = startRecording;
+exports.finishRecording = finishRecording;
+exports.getActiveRecording = getActiveRecording;
+exports.appendStep = appendStep;
+exports.appendEcho = appendEcho;
+exports.commandToYamlStep = commandToYamlStep;
+/**
+ * Active flow recording. When a path is registered for a session, successful
+ * device-action commands append themselves to the file as YAML steps.
+ *
+ * This is a *command-level* recorder — Conductor's drivers don't expose an
+ * input event channel (they receive commands, not user gestures), so we record
+ * the commands the agent issues rather than user-driven taps. Pair with
+ * `flow record start` to begin and `flow record finish` to close out.
+ */
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const session_js_1 = require("../session.js");
+const FLOWS_DIR = path_1.default.join(os_1.default.homedir(), '.conductor', 'recordings');
+function defaultRecordingPath(sessionName) {
+    const ts = new Date().toISOString().replace(/[:.]/g, '-');
+    return path_1.default.join(FLOWS_DIR, `${sessionName}-${ts}.yaml`);
+}
+async function startRecording(sessionName, out, appId) {
+    const target = out ? path_1.default.resolve(out) : defaultRecordingPath(sessionName);
+    fs_1.default.mkdirSync(path_1.default.dirname(target), { recursive: true });
+    const header = (appId ? `appId: ${appId}\n` : `# appId: <set me>\n`) +
+        `---\n# Recording started ${new Date().toISOString()}\n`;
+    fs_1.default.writeFileSync(target, header, 'utf-8');
+    await (0, session_js_1.updateSession)({ recordingPath: target }, sessionName);
+    return target;
+}
+async function finishRecording(sessionName) {
+    const session = (await (0, session_js_1.getSession)(sessionName));
+    if (!session.recordingPath)
+        return null;
+    const out = session.recordingPath;
+    fs_1.default.appendFileSync(out, `# Recording finished ${new Date().toISOString()}\n`);
+    delete session.recordingPath;
+    await (0, session_js_1.updateSession)(session, sessionName);
+    return out;
+}
+async function getActiveRecording(sessionName) {
+    const session = (await (0, session_js_1.getSession)(sessionName));
+    return session.recordingPath ?? null;
+}
+function appendStep(filePath, yamlStep) {
+    fs_1.default.appendFileSync(filePath, yamlStep.endsWith('\n') ? yamlStep : yamlStep + '\n', 'utf-8');
+}
+function appendEcho(filePath, text) {
+    fs_1.default.appendFileSync(filePath, `- runScript: |\n    console.log(${JSON.stringify(text)})\n`, 'utf-8');
+}
+/**
+ * Map a conductor command + args into one or more Maestro-flavoured YAML
+ * steps. Returns null for commands that should not be recorded (lifecycle,
+ * inspection, status). The mapping is intentionally narrow — when we cannot
+ * faithfully replay something, we omit it rather than emit a broken step.
+ */
+function commandToYamlStep(cmd, rest, argv) {
+    switch (cmd) {
+        case 'launch-app': {
+            const appId = rest[0];
+            if (!appId)
+                return null;
+            const lines = [`- launchApp:`, `    appId: ${appId}`];
+            if (argv['clear-state'])
+                lines.push(`    clearState: true`);
+            return lines.join('\n');
+        }
+        case 'stop-app':
+            return rest[0] ? `- stopApp: ${rest[0]}` : `- stopApp`;
+        case 'clear-state':
+            return rest[0] ? `- clearState:\n    appId: ${rest[0]}` : `- clearState`;
+        case 'tap-on': {
+            const text = rest.join(' ').trim();
+            const id = argv['id'];
+            const t = argv['text'];
+            if (id)
+                return `- tapOn:\n    id: ${JSON.stringify(id)}`;
+            if (t)
+                return `- tapOn:\n    text: ${JSON.stringify(t)}`;
+            if (text)
+                return `- tapOn: ${JSON.stringify(text)}`;
+            return null;
+        }
+        case 'input-text':
+            return `- inputText: ${JSON.stringify(rest.join(' '))}`;
+        case 'erase-text': {
+            const n = rest[0] ?? argv['characters'] ?? '50';
+            return `- eraseText: ${n}`;
+        }
+        case 'back':
+            return `- back`;
+        case 'hide-keyboard':
+            return `- hideKeyboard`;
+        case 'press-key':
+            return `- pressKey: ${JSON.stringify(rest[0] ?? '')}`;
+        case 'scroll':
+            return `- scroll`;
+        case 'swipe': {
+            const dir = argv['direction'] ?? 'up';
+            return `- swipe:\n    direction: ${dir}`;
+        }
+        case 'open-link':
+            return `- openLink: ${JSON.stringify(rest[0] ?? '')}`;
+        case 'set-orientation':
+            return `- setOrientation: ${rest[0] ?? argv['orientation'] ?? 'portrait'}`;
+        case 'set-location': {
+            const lat = argv['lat'] ?? argv['latitude'];
+            const lng = argv['lng'] ?? argv['longitude'];
+            if (lat === undefined || lng === undefined)
+                return null;
+            return `- setLocation:\n    latitude: ${lat}\n    longitude: ${lng}`;
+        }
+        case 'paste':
+            return `- runScript: |\n    // paste — re-record manually if needed`;
+        case 'assert-visible': {
+            const text = rest.join(' ').trim();
+            return text ? `- assertVisible: ${JSON.stringify(text)}` : null;
+        }
+        case 'assert-not-visible': {
+            const text = rest.join(' ').trim();
+            return text ? `- assertNotVisible: ${JSON.stringify(text)}` : null;
+        }
+        default:
+            return null;
+    }
+}

package/dist/drivers/flow-runner.js

@@ -18,6 +18,7 @@ const ios_js_1 = require("./ios.js");
 const android_js_1 = require("./android.js");
 const web_js_1 = require("./web.js");
 const wait_js_1 = require("./wait.js");
+const direct_ios_selector_js_1 = require("./direct-ios-selector.js");
 const perf_hooks_1 = require("perf_hooks");
 const js_engine_js_1 = require("./js-engine.js");
 const utils_js_1 = require("../utils.js");
@@ -147,7 +148,7 @@ async function waitForElement(driver, sel, timeoutMs, appIds, opts) {
     const elSel = toElementSelector(sel);
     if (driver instanceof ios_js_1.IOSDriver) {
         const iosShouldAllow = opts?.output[OUTPUT_IOS_SHOULD_ALLOW];
-        return (0, wait_js_1.waitForIOSElement)(() => iosGetHierarchy(driver, appIds ?? [], iosShouldAllow), elSel, timeoutMs);
+        return (0, wait_js_1.waitForIOSElement)((o) => iosGetHierarchy(driver, appIds ?? [], iosShouldAllow, o?.cached), elSel, timeoutMs, undefined, (0, direct_ios_selector_js_1.makeIOSDirectResolver)(driver, elSel, appIds ?? []));
     }
     else if (driver instanceof web_js_1.WebDriver) {
         return (0, wait_js_1.waitForWebElement)(() => driver.viewHierarchy(), elSel, timeoutMs);
@@ -211,10 +212,11 @@ async function tapPermissionDialog(driver, root, shouldAllow) {
  * dialog (if present) before returning so the caller sees a clean hierarchy.
  * The waitForIOSElement retry loop handles multiple dialogs across iterations.
  */
-async function iosGetHierarchy(driver, appIds, shouldAllow) {
-    const root = (await driver.viewHierarchy(false, appIds)).axElement;
+async function iosGetHierarchy(driver, appIds, shouldAllow, cached) {
+    const root = (await driver.viewHierarchy(false, appIds, { cache: cached })).axElement;
     if (shouldAllow !== undefined) {
         const tapped = await tapPermissionDialog(driver, root, shouldAllow);
+        // Re-fetch fresh after dismissing a dialog — the tap invalidated the cache.
         if (tapped)
             return (await driver.viewHierarchy(false, appIds)).axElement;
     }