swipium 1.4.0 → 2.0.0

package/dist/drivers/WdaDriver.js

@@ -1,13 +1,63 @@
+import { currentScreenSizeEpoch } from './DirectDriver.js';
 import * as sim from '../lib/simctl.js';
-import { acceptWdaAlert, clearWdaElement, clearWdaFocusedByKeys, createWdaSession, deleteWdaSession, dismissWdaAlert, dragWdaPoint, findFocusedWdaElement, findWdaElement, normalizeWdaSource, pressWdaBack, pressWdaHome, tapWdaElement, tapWdaPoint, typeWdaElement, typeWdaKeys, wdaActiveAppInfo, wdaScreenshot, wdaSessionUdidMismatch, wdaSource, } from '../lib/wda.js';
+import { currentSignal } from '../lib/abortScope.js';
+import { parseSnapshot } from '../snapshot/parse.js';
+import { acceptWdaAlert, clearWdaElement, clearWdaFocusedByKeys, createWdaSession, deleteWdaSession, dismissWdaAlert, dismissWdaKeyboard, isInvalidWdaSession, wdaKeyboardFrame, wdaKeyboardShown, wdaOrientation, withWdaCall, dragWdaPoint, findFocusedWdaElement, findWdaElement, normalizeWdaSource, pressWdaHome, tapWdaElement, tapWdaPoint, typeWdaElement, typeWdaKeys, wdaActiveAppInfo, wdaElementAttribute, wdaScreenshot, wdaSessionUdidMismatch, wdaSource, wdaWindowSize, } from '../lib/wda.js';
 const UNSUPPORTED = 'not supported by the WDA backend yet.';
+/** A cached screen size is re-validated (GET /orientation + /window/size) after this long even
+ * without an observed rotation. Rotations seen in a page source drop it immediately. */
+export const WDA_SCREEN_SIZE_TTL_MS = 30_000;
+/** How long a post-settle page source may answer `press back` (only while no action ran since and
+ * nothing invalidated the device's screen). Short on purpose: the app can navigate by itself. */
+export const WDA_BACK_SOURCE_FRESH_MS = 3_000;
+/** Per-device page-source epoch: bumped by any out-of-driver screen change on that simulator
+ * (simctl launch/terminate/openurl, app-control tools, flow openUrl) so a cached source taken
+ * before it is never reused to find a back button. Keyed by udid; '*' = every device. */
+const pageSourceEpoch = new Map();
+function sourceEpochOf(udid) {
+    return (pageSourceEpoch.get(udid ?? '') ?? 0) + (pageSourceEpoch.get('*') ?? 0);
+}
+/** Drop any WdaDriver's cached page source for `udid` (all devices when omitted). Call after any
+ * simctl / app-control action that can change the screen outside the WDA driver. */
+export function invalidateWdaPageSource(udid) {
+    const key = udid ?? '*';
+    pageSourceEpoch.set(key, (pageSourceEpoch.get(key) ?? 0) + 1);
+}
+/** How long the element id found by clearFocusedText() is reused by the following inputText(). */
+export const WDA_FOCUSED_REUSE_MS = 10_000;
 function tailLines(text, lines) {
     const all = text.split(/\r?\n/);
     return all.slice(Math.max(0, all.length - lines)).join('\n');
 }
 function errorSummary(e) {
-    return String(e?.message ?? e).replace(/\s+/g, ' ').slice(0, 300);
+    return String(e?.message ?? e)
+        .replace(/\s+/g, ' ')
+        .slice(0, 300);
+}
+/** PURE: where iOS "back" is on this screen: the center of the navigation bar's back button in a
+ * (normalized) WDA source, or null. The back button is the FIRST XCUIElementTypeButton inside the
+ * first XCUIElementTypeNavigationBar, and only when it sits in the bar's LEFT half. A root screen's
+ * bar can hold only trailing buttons ("Edit", "+"), which are not back. */
+export function iosBackButtonPoint(normalizedXml) {
+    const nodes = parseSnapshot(normalizedXml).allNodes;
+    const bar = nodes.find((n) => /XCUIElementTypeNavigationBar$/.test(n.cls));
+    if (!bar)
+        return null;
+    const btn = nodes.find((n) => n.dfs > bar.dfs &&
+        n.dfs <= bar.subtreeEnd &&
+        /XCUIElementTypeButton$/.test(n.cls) &&
+        n.enabled &&
+        n.bounds[2] > n.bounds[0] &&
+        n.bounds[3] > n.bounds[1]);
+    if (!btn)
+        return null;
+    const x = Math.round((btn.bounds[0] + btn.bounds[2]) / 2);
+    const y = Math.round((btn.bounds[1] + btn.bounds[3]) / 2);
+    const barMid = (bar.bounds[0] + bar.bounds[2]) / 2;
+    return x < barMid ? { x, y } : null;
 }
+/** Thrown (message prefix) when iOS has no way to go "back" on the current screen. */
+export const IOS_BACK_UNSUPPORTED = 'BACKEND_UNSUPPORTED: iOS has no system back key. No navigation-bar back button was found and the screen size needed for an edge-swipe back gesture is unknown.';
 export class WdaDriver {
     kind = 'wda';
     baseUrl;
@@ -16,6 +66,8 @@ export class WdaDriver {
     sessionId;
     bundleId;
     capabilities;
+    /** Every session this driver creates re-uses the running app (restart rebind). */
+    reuseRunningApp;
     settings;
     onTiming;
     constructor(baseUrl, opts = {}) {
@@ -25,6 +77,7 @@ export class WdaDriver {
         this.sessionId = opts.sessionId;
         this.bundleId = opts.bundleId;
         this.capabilities = opts.capabilities;
+        this.reuseRunningApp = opts.reuseRunningApp === true;
         this.settings = opts.settings;
         this.onTiming = opts.onTiming;
     }
@@ -37,10 +90,73 @@ export class WdaDriver {
             this.onTiming?.(kind, Date.now() - started);
         }
     }
-    async ensureSession() {
+    /** Last normalized page source from dumpXml(). It's cleared by every state-changing call, so while
+     * set it IS the current screen (as of `at`). Lets `press back` skip a fresh /source. */
+    lastSource;
+    /** Focused element found by clearFocusedText(), reused by the next inputText(). */
+    focusedEl;
+    /** Called by every state-changing operation. */
+    touched() {
+        this.lastSource = undefined;
+    }
+    /** Run a simctl app-control call (launch/terminate/install/openurl): the screen may change
+     * outside WDA, so every driver's cached source for this simulator is dropped before AND after
+     * (a source dumped while the call ran is stale too). */
+    async simctlChange(fn) {
+        this.touched();
+        invalidateWdaPageSource(this.udid);
+        try {
+            return await fn();
+        }
+        finally {
+            invalidateWdaPageSource(this.udid);
+        }
+    }
+    /** Set when a session was transparently re-created after "invalid session id" (WDA restart /
+     * session reaped). Callers may surface it as a warning via consumeSessionRecovered(). */
+    sessionRecovered = false;
+    /** Returns (and clears) whether the last operations ran on a re-created WDA session. */
+    consumeSessionRecovered() {
+        const v = this.sessionRecovered;
+        this.sessionRecovered = false;
+        return v;
+    }
+    /** Run a session-scoped WDA operation with the bound signal + per-endpoint timeouts. On
+     * "invalid session id" (WDA restarted / session reaped) the cached session is dropped and
+     * the operation retried ONCE on a fresh session; the failed request never acted. The fresh
+     * session is created with forceAppLaunch:false + shouldTerminateApp:false (reuseRunningApp) so
+     * WDA does NOT terminate + relaunch the app under test (WebDriverAgent FBSessionCommands: when
+     * `bundleId` is passed, `forceAppLaunch` defaults to YES and a running app is relaunched; with
+     * NO a running app is left as-is and a backgrounded one is only activated). */
+    async withSession(fn) {
+        return withWdaCall({ signal: currentSignal() }, async () => {
+            const sid = await this.ensureSession();
+            try {
+                return await fn(sid);
+            }
+            catch (e) {
+                if (!isInvalidWdaSession(e))
+                    throw e;
+                this.sessionId = undefined;
+                this.cachedScreenSize = undefined;
+                this.lastSource = undefined;
+                this.focusedEl = undefined;
+                const fresh = await this.ensureSession({ recover: true });
+                this.sessionRecovered = true;
+                return fn(fresh);
+            }
+        });
+    }
+    async ensureSession(opts = {}) {
         if (this.sessionId)
             return this.sessionId;
-        const s = await this.timed('session_create', () => createWdaSession(this.baseUrl, { bundleId: this.bundleId, udid: this.udid, capabilities: this.capabilities, settings: this.settings }));
+        const s = await this.timed('session_create', () => createWdaSession(this.baseUrl, {
+            bundleId: this.bundleId,
+            udid: this.udid,
+            capabilities: this.capabilities,
+            settings: this.settings,
+            reuseRunningApp: this.reuseRunningApp || opts.recover === true,
+        }));
         const mismatchedUdid = wdaSessionUdidMismatch(s.capabilities, this.udid);
         if (mismatchedUdid) {
             throw new Error(`STALE_WDA_DEVICE: WDA session is bound to ${mismatchedUdid}, not requested device ${this.udid}.`);
@@ -73,12 +189,18 @@ export class WdaDriver {
     async installApp(appPath) {
         if (!this.udid || !this.simulator.installApp)
             return this.no('app install');
-        await this.simulator.installApp(this.udid, appPath);
+        const udid = this.udid;
+        await this.simctlChange(async () => {
+            await this.simulator.installApp?.(udid, appPath);
+        });
     }
     async uninstallApp(pkg) {
         if (!this.udid || !this.simulator.uninstallApp)
             return this.no('app uninstall');
-        await this.simulator.uninstallApp(this.udid, pkg);
+        const udid = this.udid;
+        await this.simctlChange(async () => {
+            await this.simulator.uninstallApp?.(udid, pkg);
+        });
     }
     async isInstalled(pkg) {
         const target = pkg || this.bundleId;
@@ -108,16 +230,22 @@ export class WdaDriver {
         }
     }
     async launchApp(pkg) {
+        this.touched();
         this.bundleId = pkg;
-        if (this.udid) {
-            await this.simulator.launchApp(this.udid, pkg);
+        const udid = this.udid;
+        if (udid) {
+            await this.simctlChange(() => this.simulator.launchApp(udid, pkg));
         }
         await this.ensureSession();
     }
     async launchAppWithArgs(pkg, args) {
+        this.touched();
         this.bundleId = pkg;
-        if (this.udid && this.simulator.launchAppWithArgs) {
-            await this.simulator.launchAppWithArgs(this.udid, pkg, args);
+        const udid = this.udid;
+        if (udid && this.simulator.launchAppWithArgs) {
+            await this.simctlChange(async () => {
+                await this.simulator.launchAppWithArgs?.(udid, pkg, args);
+            });
         }
         else if (Object.keys(args).length) {
             return this.no('launch arguments');
@@ -128,20 +256,52 @@ export class WdaDriver {
         const target = pkg || this.bundleId;
         if (!this.udid || !target)
             return this.no('app terminate');
-        await this.simulator.terminateApp(this.udid, target);
+        const udid = this.udid;
+        await this.simctlChange(() => this.simulator.terminateApp(udid, target));
     }
     clearData() {
         return this.no('clear app data');
     }
-    imeShown() {
-        return Promise.resolve(false);
+    /** Keyboard shown? A single find-by-class-name call (XCUIElementTypeKeyboard). */
+    async imeShown() {
+        return this.withSession((sid) => wdaKeyboardShown(this.baseUrl, sid));
+    }
+    async imeFrame() {
+        return this.withSession((sid) => wdaKeyboardFrame(this.baseUrl, sid));
+    }
+    /** imeShown + imeFrame in ONE keyboard lookup (both used to run the same /elements query):
+     * no keyboard element (or no usable rect) ⇒ not shown. */
+    async imeState() {
+        const frame = await this.imeFrame();
+        return { shown: frame !== null, frame };
+    }
+    async hideKeyboard() {
+        this.touched();
+        return this.withSession(async (sid) => {
+            if (!(await wdaKeyboardShown(this.baseUrl, sid)))
+                return false;
+            try {
+                await dismissWdaKeyboard(this.baseUrl, sid);
+            }
+            catch (e) {
+                if (isInvalidWdaSession(e))
+                    throw e; // let withSession recover the session
+                // WDA 400 "Did not know how to dismiss the keyboard": the app offers no generic way
+                // (no Done/Return-dismiss). Report "could not hide" instead of an untyped error.
+                return false;
+            }
+            return true;
+        });
     }
     async logcat(lines = 200, grep) {
         if (!this.udid)
             return this.no('iOS simulator log capture without a simulator UDID');
         const raw = await this.simulator.simulatorLogs(this.udid, { last: '5m', bundleId: this.bundleId });
         const filtered = grep
-            ? raw.split(/\r?\n/).filter((line) => new RegExp(grep, 'i').test(line)).join('\n')
+            ? raw
+                .split(/\r?\n/)
+                .filter((line) => new RegExp(grep, 'i').test(line))
+                .join('\n')
             : raw;
         return tailLines(filtered, lines);
     }
@@ -152,32 +312,74 @@ export class WdaDriver {
         return this.no('airplane-mode toggle');
     }
     async foregroundOwner() {
-        try {
-            const info = await wdaActiveAppInfo(this.baseUrl, await this.ensureSession());
-            return info.bundleId ?? info.name ?? this.bundleId ?? 'unknown';
-        }
-        catch {
-            return this.bundleId ?? 'unknown';
+        // Never guess the app under test on failure: callers treat 'unknown' as "don't judge", while a
+        // guessed bundleId made qa_app_control background report the app as still in front.
+        for (let attempt = 0; attempt < 2; attempt++) {
+            try {
+                const info = await this.withSession((sid) => wdaActiveAppInfo(this.baseUrl, sid));
+                return info.bundleId || info.name || 'unknown';
+            }
+            catch {
+                if (attempt === 0)
+                    await new Promise((r) => setTimeout(r, 300));
+            }
         }
+        return 'unknown';
     }
     async screenshot() {
-        const sid = await this.ensureSession();
-        return this.timed('screenshot', () => wdaScreenshot(this.baseUrl, sid));
-    }
-    async dumpXml() {
-        const sid = await this.ensureSession();
-        return normalizeWdaSource(await this.timed('source', () => wdaSource(this.baseUrl, sid)));
+        return this.withSession((sid) => this.timed('screenshot', () => wdaScreenshot(this.baseUrl, sid)));
+    }
+    async dumpXml(opts = {}) {
+        // opts.timeoutMs bounds the /source request (default 30 s). The settle loop passes its
+        // remaining deadline. Retries are the caller's loop; WDA itself is not retried here.
+        let sid;
+        const xml = normalizeWdaSource(await withWdaCall({ timeoutMs: opts.timeoutMs }, () => this.withSession((s) => {
+            sid = s;
+            return this.timed('source', () => wdaSource(this.baseUrl, s));
+        })));
+        this.lastSource = { sid, xml, at: Date.now(), epoch: sourceEpochOf(this.udid) };
+        this.noteSourceSize(xml);
+        return xml;
+    }
+    /** A page source whose root size is the cached size with SWAPPED axes = a rotation happened. */
+    noteSourceSize(xml) {
+        const c = this.cachedScreenSize;
+        if (!c)
+            return;
+        const m = xml.match(/bounds="\[0,0\]\[(\d+),(\d+)\]"/);
+        if (!m)
+            return;
+        const [w, h] = [Number(m[1]), Number(m[2])];
+        if (w === c.size.height && h === c.size.width && w !== h)
+            this.cachedScreenSize = undefined;
     }
     async tapXY(x, y) {
-        const sid = await this.ensureSession();
-        await this.timed('tap', () => tapWdaPoint(this.baseUrl, sid, x, y));
+        this.touched();
+        await this.withSession((sid) => this.timed('tap', () => tapWdaPoint(this.baseUrl, sid, x, y)));
     }
     async pressXY(x, y) {
         await this.tapXY(x, y);
     }
     async inputText(text) {
-        const sid = await this.ensureSession();
+        this.touched();
+        return this.withSession((sid) => this.inputTextIn(sid, text));
+    }
+    async inputTextIn(sid, text) {
         let focusedError;
+        // Reuse the element clearFocusedText() just found (saves one find round trip per type);
+        // on any failure fall through to a fresh lookup.
+        const reuse = this.focusedEl;
+        this.focusedEl = undefined;
+        if (reuse && reuse.sid === sid && Date.now() - reuse.at < WDA_FOCUSED_REUSE_MS) {
+            try {
+                await this.timed('type', () => typeWdaElement(this.baseUrl, sid, reuse.elementId, text));
+                return;
+            }
+            catch (e) {
+                if (isInvalidWdaSession(e))
+                    throw e;
+            }
+        }
         try {
             const el = await this.timed('find_element', () => findFocusedWdaElement(this.baseUrl, sid));
             await this.timed('type', () => typeWdaElement(this.baseUrl, sid, el.elementId, text));
@@ -191,15 +393,20 @@ export class WdaDriver {
             return;
         }
         catch (keysError) {
-            throw new Error(`TEXT_INPUT_UNSUPPORTED: WDA could not type into the focused input. focused-element path failed: ${errorSummary(focusedError)}; /wda/keys path failed: ${errorSummary(keysError)}`);
+            throw new Error(`TEXT_INPUT_UNSUPPORTED: WDA could not type into the focused input. focused-element path failed: ${errorSummary(focusedError)}; /wda/keys path failed: ${errorSummary(keysError)}`, { cause: keysError });
         }
     }
     async clearFocusedText(approxLen = 40) {
-        const sid = await this.ensureSession();
+        this.touched();
+        return this.withSession((sid) => this.clearFocusedTextIn(sid, approxLen));
+    }
+    async clearFocusedTextIn(sid, approxLen) {
         let clearError;
+        this.focusedEl = undefined;
         try {
             const el = await this.timed('find_element', () => findFocusedWdaElement(this.baseUrl, sid));
             await this.timed('clear', () => clearWdaElement(this.baseUrl, sid, el.elementId));
+            this.focusedEl = { sid, elementId: el.elementId, at: Date.now() };
             return;
         }
         catch (e) {
@@ -209,36 +416,112 @@ export class WdaDriver {
             await this.timed('clear', () => clearWdaFocusedByKeys(this.baseUrl, sid, approxLen));
         }
         catch (keysError) {
-            throw new Error(`TEXT_INPUT_UNSUPPORTED: WDA could not clear the focused field. element-clear path failed: ${errorSummary(clearError)}; keyboard-backspace path failed: ${errorSummary(keysError)}`);
+            throw new Error(`TEXT_INPUT_UNSUPPORTED: WDA could not clear the focused field. element-clear path failed: ${errorSummary(clearError)}; keyboard-backspace path failed: ${errorSummary(keysError)}`, { cause: keysError });
         }
     }
     async pressKey(key) {
+        const cached = this.lastSource; // the screen as last dumped, if nothing acted since
+        this.touched();
         if (key === 'home') {
-            await pressWdaHome(this.baseUrl, await this.ensureSession());
+            await this.withSession(() => pressWdaHome(this.baseUrl)); // session-less route; session kept warm
             return;
         }
         if (key === 'back') {
-            await pressWdaBack(this.baseUrl, await this.ensureSession());
+            // iOS has no system back key (WDA has no /back endpoint): tap the navigation bar's back
+            // button when the screen has one, else perform the interactive-pop edge swipe.
+            await this.withSession((sid) => this.backIn(sid, cached && cached.sid === sid && cached.epoch === sourceEpochOf(this.udid) && Date.now() - cached.at < WDA_BACK_SOURCE_FRESH_MS
+                ? cached.xml
+                : undefined));
             return;
         }
         await this.inputText('\n');
     }
+    /** Last `back` strategy used ('nav_button' | 'edge_swipe'), surfaced by qa_act. */
+    lastBackVia;
+    async backIn(sid, cachedXml) {
+        // The latest post-settle source (nothing acted since) is the current screen: try its back
+        // button first and only fetch a fresh /source when it has none.
+        const cachedBtn = cachedXml ? iosBackButtonPoint(cachedXml) : null;
+        if (cachedBtn) {
+            await this.timed('tap', () => tapWdaPoint(this.baseUrl, sid, cachedBtn.x, cachedBtn.y));
+            this.lastBackVia = 'nav_button';
+            return;
+        }
+        const xml = normalizeWdaSource(await this.timed('source', () => wdaSource(this.baseUrl, sid)));
+        const btn = iosBackButtonPoint(xml);
+        if (btn) {
+            await this.timed('tap', () => tapWdaPoint(this.baseUrl, sid, btn.x, btn.y));
+            this.lastBackVia = 'nav_button';
+            return;
+        }
+        let size = null;
+        try {
+            size = await wdaWindowSize(this.baseUrl, sid);
+        }
+        catch (e) {
+            if (isInvalidWdaSession(e))
+                throw e;
+            const screen = parseSnapshot(xml).screen;
+            size = screen[0] > 0 && screen[1] > 0 ? { width: screen[0], height: screen[1] } : null;
+        }
+        if (!size)
+            throw new Error(IOS_BACK_UNSUPPORTED);
+        const y = Math.round(size.height / 2);
+        await dragWdaPoint(this.baseUrl, sid, 2, y, Math.round(size.width * 0.6), y, 0.1);
+        this.lastBackVia = 'edge_swipe';
+    }
     async acceptAlert() {
-        await acceptWdaAlert(this.baseUrl, await this.ensureSession());
+        this.touched();
+        await this.withSession((sid) => acceptWdaAlert(this.baseUrl, sid));
     }
     async dismissAlert() {
-        await dismissWdaAlert(this.baseUrl, await this.ensureSession());
+        this.touched();
+        await this.withSession((sid) => dismissWdaAlert(this.baseUrl, sid));
     }
     async swipe(x1, y1, x2, y2, ms = 300) {
-        await dragWdaPoint(this.baseUrl, await this.ensureSession(), x1, y1, x2, y2, ms / 1000);
+        this.touched();
+        await this.withSession((sid) => dragWdaPoint(this.baseUrl, sid, x1, y1, x2, y2, ms / 1000));
     }
     adbReverseMetro() {
         return this.no('dev-server port reverse');
     }
+    // Size in points via GET /window/size instead of dumping the entire page source.
+    // Cached per WDA session (a new session naturally misses it) WITHOUT a per-call /orientation
+    // round trip: the cache is dropped when a page source shows the axes swapped (rotation), when
+    // Swipium changes the orientation (invalidateScreenSizeCache epoch), and after
+    // WDA_SCREEN_SIZE_TTL_MS. On a miss, /orientation is still read to key the new entry.
+    cachedScreenSize;
     async screenSize() {
-        const xml = await this.dumpXml();
-        const m = xml.match(/bounds="\[0,0\]\[(\d+),(\d+)\]"/);
-        return m ? { width: Number(m[1]), height: Number(m[2]) } : null;
+        const hit = this.cachedScreenSize;
+        if (hit &&
+            hit.sessionId === this.sessionId &&
+            hit.epoch === currentScreenSizeEpoch(this.udid) &&
+            Date.now() - hit.at < WDA_SCREEN_SIZE_TTL_MS)
+            return { ...hit.size };
+        return this.withSession(async (sid) => {
+            const epoch = currentScreenSizeEpoch(this.udid);
+            const orientation = await wdaOrientation(this.baseUrl, sid).catch(() => 'unknown');
+            const cached = this.cachedScreenSize;
+            if (cached?.sessionId === sid && cached.orientation === orientation && cached.epoch === epoch) {
+                cached.at = Date.now();
+                return { ...cached.size };
+            }
+            let size;
+            try {
+                size = await wdaWindowSize(this.baseUrl, sid);
+            }
+            catch (e) {
+                if (isInvalidWdaSession(e))
+                    throw e;
+                // older WDA builds lack /window/size, so fall back to the page-source root bounds
+                const xml = normalizeWdaSource(await this.timed('source', () => wdaSource(this.baseUrl, sid)));
+                const m = xml.match(/bounds="\[0,0\]\[(\d+),(\d+)\]"/);
+                size = m ? { width: Number(m[1]), height: Number(m[2]) } : null;
+            }
+            if (size)
+                this.cachedScreenSize = { sessionId: sid, orientation, epoch, at: Date.now(), size };
+            return size;
+        });
     }
     screenDensity() {
         return Promise.resolve(null);
@@ -246,7 +529,8 @@ export class WdaDriver {
     async openUrl(url) {
         if (!this.udid)
             return this.no('open url without a simulator UDID');
-        await this.simulator.openUrl(this.udid, url);
+        const udid = this.udid;
+        await this.simctlChange(() => this.simulator.openUrl(udid, url));
     }
     disableAnimations() {
         return Promise.resolve();
@@ -258,29 +542,55 @@ export class WdaDriver {
         await this.typeBySelector('accessibility id', value, text);
     }
     async tapBySelector(using, value) {
-        const sid = await this.ensureSession();
-        const el = await this.timed('find_element', () => findWdaElement(this.baseUrl, sid, using, value));
-        await this.timed('tap', () => tapWdaElement(this.baseUrl, sid, el.elementId));
+        this.touched();
+        await this.withSession(async (sid) => {
+            const el = await this.timed('find_element', () => findWdaElement(this.baseUrl, sid, using, value));
+            await this.timed('tap', () => tapWdaElement(this.baseUrl, sid, el.elementId));
+        });
     }
     async typeBySelector(using, value, text) {
-        const sid = await this.ensureSession();
-        const el = await this.timed('find_element', () => findWdaElement(this.baseUrl, sid, using, value));
-        await this.timed('type', () => typeWdaElement(this.baseUrl, sid, el.elementId, text));
+        this.touched();
+        await this.withSession(async (sid) => {
+            const el = await this.timed('find_element', () => findWdaElement(this.baseUrl, sid, using, value));
+            await this.timed('type', () => typeWdaElement(this.baseUrl, sid, el.elementId, text));
+        });
     }
     async clearBySelector(using, value) {
-        const sid = await this.ensureSession();
-        const el = await this.timed('find_element', () => findWdaElement(this.baseUrl, sid, using, value));
-        await this.timed('clear', () => clearWdaElement(this.baseUrl, sid, el.elementId));
+        this.touched();
+        await this.withSession(async (sid) => {
+            const el = await this.timed('find_element', () => findWdaElement(this.baseUrl, sid, using, value));
+            await this.timed('clear', () => clearWdaElement(this.baseUrl, sid, el.elementId));
+        });
     }
-    async existsBySelector(using, value) {
-        const sid = await this.ensureSession();
+    // Real secure-field signal for native-selector typing: resolve the element and
+    // read its `type` attribute (XCUIElementTypeSecureTextField), accepting a boolean `secure`
+    // attribute where a WDA build exposes one instead.
+    async isSecureBySelector(using, value) {
+        return this.withSession((sid) => this.isSecureIn(sid, using, value));
+    }
+    async isSecureIn(sid, using, value) {
+        const el = await this.timed('find_element', () => findWdaElement(this.baseUrl, sid, using, value));
         try {
-            await this.timed('find_element', () => findWdaElement(this.baseUrl, sid, using, value));
-            return true;
+            if (/SecureTextField/i.test(await wdaElementAttribute(this.baseUrl, sid, el.elementId, 'type')))
+                return true;
         }
         catch {
-            return false;
+            // some builds don't serve /attribute/type, so fall through to the `secure` attribute
         }
+        return /^(true|1)$/i.test(await wdaElementAttribute(this.baseUrl, sid, el.elementId, 'secure').catch(() => ''));
+    }
+    async existsBySelector(using, value) {
+        return this.withSession(async (sid) => {
+            try {
+                await this.timed('find_element', () => findWdaElement(this.baseUrl, sid, using, value));
+                return true;
+            }
+            catch (e) {
+                if (isInvalidWdaSession(e))
+                    throw e; // let withSession recover the session
+                return false;
+            }
+        });
     }
 }
 //# sourceMappingURL=WdaDriver.js.map