@taqwright/taqwright 0.0.24

package/dist/fixture/index.js

@@ -0,0 +1,324 @@
+import { promises as fs } from 'node:fs';
+import { test as baseTest } from '@playwright/test';
+import WebDriver from 'webdriver';
+import { Mobile } from '../mobile/index.js';
+import { Platform, } from '../types/index.js';
+import { getUseOptions, loadTaqwrightConfig } from '../config.js';
+import { resolvedPoolEnvKey } from '../discovery.js';
+import { appiumRemoteOptions } from '../capabilities.js';
+import { isPortOpen } from '../auto-appium.js';
+import { startAppiumServer } from '../providers/appium.js';
+import { resolveAndroidSerial, waitForAndroidDeviceReady, isTransientDeviceError, } from '../inspector/devices.js';
+import { logger } from '../logger.js';
+import { avdBootPreflightError, bootableAvdName } from '../setup/avd.js';
+import { createDeviceProvider, isCloudProvider } from '../providers/index.js';
+import { Tracer } from '../tracer/index.js';
+import { wrapForTracing } from '../tracer/proxy.js';
+import { shouldRetainArtifact } from './artifact-mode.js';
+import { prepareNetworkProxy, configureDeviceForCapture, teardownDeviceCapture, teardownNetworkProxy, extractUdid, } from '../network/index.js';
+const DEFAULT_TIMEOUT = 30_000;
+const VIDEO_TIME_LIMIT_SECONDS = 1800;
+const LOCAL_RETRY_ATTEMPTS = 3;
+async function localAndroidSerial(use) {
+    const device = use.device;
+    const isLocal = device.provider === 'emulator' || device.provider === 'local-device';
+    if (use.platform !== Platform.ANDROID || !isLocal)
+        return undefined;
+    const avdName = typeof device.name === 'string' ? device.name : undefined;
+    return resolveAndroidSerial({ udid: device.udid, avdName });
+}
+async function withDeviceReadyRetry(serial, label, fn) {
+    let lastErr;
+    for (let attempt = 1; attempt <= LOCAL_RETRY_ATTEMPTS; attempt++) {
+        const ready = await waitForAndroidDeviceReady(serial);
+        if (!ready) {
+            logger.warn(`taqwright: ${serial} not reporting ready before ${label} attempt ${attempt}/${LOCAL_RETRY_ATTEMPTS} — trying anyway.`);
+        }
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastErr = err;
+            const message = err instanceof Error ? err.message : String(err);
+            if (attempt < LOCAL_RETRY_ATTEMPTS && isTransientDeviceError(message)) {
+                logger.warn(`taqwright: transient device error on ${serial} during ${label} (attempt ${attempt}/${LOCAL_RETRY_ATTEMPTS}), waiting for it to recover and retrying — ${message}`);
+                continue;
+            }
+            throw err;
+        }
+    }
+    throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
+}
+async function createLocalSession(use) {
+    const newSession = () => WebDriver.newSession(appiumRemoteOptions(use));
+    const serial = await localAndroidSerial(use);
+    if (!serial) {
+        const device = use.device;
+        const avdName = typeof device.name === 'string' ? device.name : undefined;
+        if (use.platform === Platform.ANDROID &&
+            device.provider === 'emulator' &&
+            avdName &&
+            use.appium?.autoStartDevice !== false) {
+            const err = await avdBootPreflightError(avdName);
+            if (err)
+                throw new Error(err);
+        }
+        return newSession();
+    }
+    return withDeviceReadyRetry(serial, 'session creation', newSession);
+}
+export const test = baseTest.extend({
+    taqwrightUse: [
+        async ({}, use, workerInfo) => {
+            const config = await loadTaqwrightConfig();
+            const projectName = workerInfo.project.name || undefined;
+            const useOpts = getUseOptions(config, projectName);
+            if (!useOpts) {
+                throw new Error(`taqwright: no project found in taqwright.config.ts${projectName ? ` matching "${projectName}"` : ''}`);
+            }
+            const idx = workerInfo.parallelIndex;
+            const dev = useOpts.device;
+            let pool = dev.pool;
+            if ((!pool || pool.length === 0) && dev.autoDiscover) {
+                const resolved = process.env[resolvedPoolEnvKey(projectName)];
+                if (!resolved) {
+                    throw new Error(`taqwright: device.autoDiscover is set on project "${projectName ?? ''}" but no ` +
+                        `resolved device pool was found — the globalSetup hook did not run. Launch via ` +
+                        `\`taqwright test\` (or Playwright with the generated config).`);
+                }
+                pool = JSON.parse(resolved);
+            }
+            if (!pool || pool.length === 0) {
+                await use(useOpts);
+                return;
+            }
+            if (idx >= pool.length) {
+                throw new Error(`taqwright: worker #${idx} has no device — pool has ${pool.length} entr${pool.length === 1 ? 'y' : 'ies'}. Reduce \`workers\` or grow the pool.`);
+            }
+            const slot = pool[idx];
+            const baseAppiumPort = useOpts.appium?.port ?? 4723;
+            const partitioned = {
+                ...useOpts,
+                device: {
+                    ...useOpts.device,
+                    udid: slot.udid,
+                    name: slot.name ?? useOpts.device.name,
+                    osVersion: slot.osVersion ?? useOpts.device.osVersion,
+                },
+                appium: { ...useOpts.appium, port: baseAppiumPort + idx },
+                capabilities: {
+                    ...(useOpts.capabilities ?? {}),
+                    'appium:systemPort': 8200 + idx,
+                    'appium:chromedriverPort': 9515 + idx,
+                    'appium:mjpegServerPort': 7810 + idx,
+                    'appium:wdaLocalPort': 8100 + idx,
+                    'appium:derivedDataPath': `/tmp/wda-${idx}`,
+                },
+            };
+            let proc;
+            if (partitioned.appium?.autoStart &&
+                partitioned.appium.host &&
+                partitioned.appium.port !== undefined &&
+                !(await isPortOpen(partitioned.appium.host, partitioned.appium.port))) {
+                proc = await startAppiumServer('worker', {
+                    host: partitioned.appium.host,
+                    port: partitioned.appium.port,
+                    basePath: partitioned.appium.path,
+                }, bootableAvdName(partitioned));
+            }
+            try {
+                await use(partitioned);
+            }
+            finally {
+                if (proc && !proc.killed)
+                    proc.kill();
+            }
+        },
+        { scope: 'worker' },
+    ],
+    deviceProvider: [
+        async ({ taqwrightUse }, use, workerInfo) => {
+            const provider = taqwrightUse.device.provider;
+            if (!isCloudProvider(provider)) {
+                await use(null);
+                return;
+            }
+            const dp = createDeviceProvider(taqwrightUse, workerInfo.project.name || undefined);
+            if (dp.globalSetup)
+                await dp.globalSetup();
+            await use(dp);
+        },
+        { scope: 'worker' },
+    ],
+    networkProxy: async ({ taqwrightUse, deviceProvider }, use, testInfo) => {
+        const networkMode = taqwrightUse.network ?? 'off';
+        if (networkMode === 'off' || deviceProvider !== null) {
+            await use(null);
+            return;
+        }
+        let handle;
+        try {
+            handle = await prepareNetworkProxy({
+                platform: taqwrightUse.platform,
+                parallelIndex: testInfo.parallelIndex,
+            });
+        }
+        catch (err) {
+            handle = null;
+            console.warn(`taqwright: network capture disabled — ${err.message}`);
+        }
+        try {
+            await use(handle);
+        }
+        finally {
+            if (handle)
+                await teardownNetworkProxy(handle);
+        }
+    },
+    rawDriver: async ({ taqwrightUse, deviceProvider, networkProxy }, use, testInfo) => {
+        if (!deviceProvider) {
+            const driver = await createLocalSession(taqwrightUse);
+            if (networkProxy) {
+                const udid = extractUdid(driver.capabilities) ?? taqwrightUse.device.udid;
+                await configureDeviceForCapture(networkProxy, {
+                    udid,
+                    platform: taqwrightUse.platform,
+                });
+            }
+            try {
+                await use(driver);
+            }
+            finally {
+                if (networkProxy) {
+                    await teardownDeviceCapture(networkProxy);
+                }
+                try {
+                    await driver.deleteSession();
+                }
+                catch {
+                }
+            }
+            return;
+        }
+        const handle = await deviceProvider.getDevice();
+        try {
+            await use(handle.driver);
+        }
+        finally {
+            if (deviceProvider.syncTestDetails) {
+                try {
+                    const failed = testInfo.status !== 'passed';
+                    await deviceProvider.syncTestDetails({
+                        status: failed ? 'failed' : 'passed',
+                        reason: testInfo.error?.message ?? (failed ? testInfo.status : 'taqwright test passed'),
+                        name: testInfo.title,
+                    });
+                }
+                catch {
+                }
+            }
+            try {
+                await handle.driver.deleteSession();
+            }
+            catch {
+            }
+        }
+    },
+    mobile: async ({ rawDriver, taqwrightUse, networkProxy }, use, testInfo) => {
+        const platform = taqwrightUse.platform;
+        const bundleId = taqwrightUse.appBundleId;
+        const timeout = taqwrightUse.expectTimeout ?? DEFAULT_TIMEOUT;
+        const isCloud = isCloudProvider(taqwrightUse.device.provider);
+        if (!isCloud && taqwrightUse.resetBetweenTests && bundleId && taqwrightUse.buildPath) {
+            const appRef = platform === Platform.IOS ? { bundleId } : { appId: bundleId };
+            const installArg = platform === Platform.IOS
+                ? { app: taqwrightUse.buildPath }
+                : { appPath: taqwrightUse.buildPath };
+            const doReset = async () => {
+                await rawDriver.executeScript('mobile: terminateApp', [appRef]).catch(() => { });
+                await rawDriver.executeScript('mobile: removeApp', [appRef]).catch(() => { });
+                await rawDriver.executeScript('mobile: installApp', [installArg]);
+                await rawDriver.executeScript('mobile: activateApp', [appRef]);
+            };
+            const serial = await localAndroidSerial(taqwrightUse);
+            if (serial)
+                await withDeviceReadyRetry(serial, 'reset-between-tests', doReset);
+            else
+                await doReset();
+        }
+        const mobile = Mobile.wrap(rawDriver, platform, bundleId, timeout);
+        const videoMode = taqwrightUse.video ?? 'off';
+        const videoOn = videoMode !== 'off' && !isCloud;
+        if (videoOn) {
+            const recordOpts = platform === Platform.IOS
+                ? {
+                    timeLimit: String(VIDEO_TIME_LIMIT_SECONDS),
+                    videoType: 'libx264',
+                    videoQuality: 'medium',
+                }
+                : { timeLimit: String(VIDEO_TIME_LIMIT_SECONDS) };
+            await rawDriver.startRecordingScreen(recordOpts);
+        }
+        const traceMode = taqwrightUse.trace ?? 'off';
+        let tracer = null;
+        let tracedMobile = mobile;
+        if (traceMode !== 'off') {
+            tracer = new Tracer(rawDriver, platform);
+            tracedMobile = wrapForTracing(mobile, tracer);
+        }
+        try {
+            await use(tracedMobile);
+        }
+        finally {
+            if (videoOn) {
+                let data;
+                try {
+                    data = (await rawDriver.stopRecordingScreen());
+                }
+                catch {
+                }
+                const failed = testInfo.status !== 'passed';
+                if (data && shouldRetainArtifact(videoMode, failed)) {
+                    const buf = Buffer.from(data, 'base64');
+                    if (buf.length > 0) {
+                        const path = testInfo.outputPath('screen.mp4');
+                        await fs.writeFile(path, buf);
+                        await testInfo.attach('taqwright-video', { path, contentType: 'video/mp4' });
+                    }
+                }
+            }
+            let har;
+            if (networkProxy) {
+                try {
+                    har = (await networkProxy.flush());
+                }
+                catch {
+                }
+                const networkMode = taqwrightUse.network ?? 'off';
+                const failed = testInfo.status !== 'passed';
+                if (har && shouldRetainArtifact(networkMode, failed)) {
+                    const path = testInfo.outputPath('network.har');
+                    await fs.writeFile(path, JSON.stringify(har, null, 2), 'utf-8');
+                    await testInfo.attach('taqwright-har', {
+                        path,
+                        contentType: 'application/json',
+                    });
+                }
+            }
+            if (tracer) {
+                const failed = testInfo.status !== 'passed';
+                if (shouldRetainArtifact(traceMode, failed)) {
+                    const path = testInfo.outputPath('trace.html');
+                    const html = tracer.toHtml({
+                        title: testInfo.title,
+                        status: testInfo.status,
+                        duration: testInfo.duration,
+                        project: { name: testInfo.project.name },
+                    }, { har: har ?? null });
+                    await fs.writeFile(path, html, 'utf-8');
+                    await testInfo.attach('taqwright-trace', { path, contentType: 'text/html' });
+                }
+            }
+        }
+    },
+});

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { test } from './fixture/index.js';
+export { expect, type TaqwrightExpect, type MobileMatchers } from './expect.js';
+export { Mobile } from './mobile/index.js';
+export { Locator } from './locator/index.js';
+export { defineConfig, loadTaqwrightConfig as loadConfig } from './config.js';
+export { iosParallelCaps, type IosParallelCapsOptions } from './capabilities-helpers.js';
+export { Platform, type TaqwrightConfig, type TaqwrightProjectConfig, type TaqwrightUseOptions, type AppiumServerConfig, type DeviceConfig, type EmulatorDeviceConfig, type LocalDeviceConfig, type ScrollDirection, type SwipeDirection, type HardwareButton, type BoundingBox, type ScreenSize, type GestureOptions, type GesturePointer, type TraceMode, type VideoMode, } from './types/index.js';
+export type { ClickPoint, SwipeOptions, GetByOptions, LaunchAppOptions, GeoLocation, NetworkConnection, DeviceLogEntry, ScreenRecordingOptions, PauseOptions, } from './mobile/index.js';
+export type { WaitForOptions, ActionOptions, LongPressOptions, ScrollIntoViewOptions, ElementSwipeOptions, DragOptions, LocatorFilterOptions, SelectOptionInput, PressSequentiallyOptions, } from './locator/index.js';

package/dist/index.js

@@ -0,0 +1,7 @@
+export { test } from './fixture/index.js';
+export { expect } from './expect.js';
+export { Mobile } from './mobile/index.js';
+export { Locator } from './locator/index.js';
+export { defineConfig, loadTaqwrightConfig as loadConfig } from './config.js';
+export { iosParallelCaps } from './capabilities-helpers.js';
+export { Platform, } from './types/index.js';

package/dist/inspector/codegen-appium.d.ts

@@ -0,0 +1,3 @@
+import type { RecordedAction } from './recorder.js';
+export declare function toStepsPython(actions: RecordedAction[]): string;
+export declare function toStepsJava(actions: RecordedAction[]): string;

package/dist/inspector/codegen-appium.js

@@ -0,0 +1,228 @@
+const PY_BY = {
+    id: 'AppiumBy.ID',
+    'accessibility id': 'AppiumBy.ACCESSIBILITY_ID',
+    xpath: 'AppiumBy.XPATH',
+    '-android uiautomator': 'AppiumBy.ANDROID_UIAUTOMATOR',
+    '-ios predicate string': 'AppiumBy.IOS_PREDICATE',
+    '-ios class chain': 'AppiumBy.IOS_CLASS_CHAIN',
+    'class name': 'AppiumBy.CLASS_NAME',
+    name: 'AppiumBy.NAME',
+    'css selector': 'AppiumBy.CSS_SELECTOR',
+};
+const JAVA_BY = {
+    id: 'id',
+    'accessibility id': 'accessibilityId',
+    xpath: 'xpath',
+    '-android uiautomator': 'androidUIAutomator',
+    '-ios predicate string': 'iOSNsPredicateString',
+    '-ios class chain': 'iOSClassChain',
+    'class name': 'className',
+    name: 'name',
+};
+function str(s) {
+    return JSON.stringify(s);
+}
+function leafOf(loc) {
+    const d = loc.descriptor;
+    if (d) {
+        if (d.kind === 'leaf')
+            return { using: d.using, value: d.value };
+        if (d.kind === 'nth' && d.on.kind === 'leaf')
+            return { using: d.on.using, value: d.on.value, n: d.n };
+        if (d.kind === 'first' && d.on.kind === 'leaf')
+            return { using: d.on.using, value: d.on.value, n: 0 };
+        return null;
+    }
+    if (loc.using !== undefined && loc.value !== undefined)
+        return { using: loc.using, value: loc.value };
+    return null;
+}
+function pyTuple(leaf) {
+    const by = PY_BY[leaf.using];
+    if (!by)
+        return null;
+    return `(${by}, ${str(leaf.value)})`;
+}
+function pyElement(leaf) {
+    const tuple = pyTuple(leaf);
+    if (!tuple)
+        return null;
+    return leaf.n === undefined
+        ? `driver.find_element${tuple}`
+        : `driver.find_elements${tuple}[${leaf.n}]`;
+}
+function javaBy(leaf) {
+    const fn = JAVA_BY[leaf.using];
+    if (!fn)
+        return null;
+    return `AppiumBy.${fn}(${str(leaf.value)})`;
+}
+function javaElement(leaf) {
+    const by = javaBy(leaf);
+    if (!by)
+        return null;
+    return leaf.n === undefined
+        ? `driver.findElement(${by})`
+        : `driver.findElements(${by}).get(${leaf.n})`;
+}
+const PY_WAIT = 'WebDriverWait(driver, 10).until';
+const JAVA_WAIT = 'new WebDriverWait(driver, Duration.ofSeconds(10)).until';
+function pyTodo(a) {
+    return `# TODO: ${a.kind} has no direct Appium-Python-Client equivalent (taqwright: ${tsHint(a)})`;
+}
+function javaTodo(a) {
+    return `// TODO: ${a.kind} has no direct Appium java-client equivalent (taqwright: ${tsHint(a)})`;
+}
+function tsHint(a) {
+    return 'code' in a && typeof a.code === 'string' ? a.code : a.kind;
+}
+function renderPy(a) {
+    switch (a.kind) {
+        case 'comment':
+            return `# ${a.text}`;
+        case 'sendKeys':
+            return `driver.execute_script("mobile: type", {"text": ${str(a.text)}})`;
+        case 'switchContext':
+            return /^NATIVE_APP$/i.test(a.context)
+                ? `driver.switch_to.context("NATIVE_APP")`
+                : `driver.switch_to.context(${str(a.context)})  # NOTE: WebView handles vary across runs`;
+        case 'tap':
+        case 'swipe':
+        case 'screenScroll':
+            return pyTodo(a);
+        default:
+            break;
+    }
+    const leaf = leafOf(a);
+    if (!leaf)
+        return pyTodo(a);
+    const el = pyElement(leaf);
+    const tuple = pyTuple(leaf);
+    if (!el || !tuple)
+        return pyTodo(a);
+    switch (a.kind) {
+        case 'locatorClick':
+            return `${el}.click()`;
+        case 'locatorFill':
+            return `${el}.send_keys(${str(a.text)})`;
+        case 'locatorClear':
+            return `${el}.clear()`;
+        case 'locatorPressSequentially':
+            return `${el}.send_keys(${str(a.text)})${a.delay ? '  # delay not supported by send_keys' : ''}`;
+        case 'locatorCheck':
+            return `${el}.click()  # check: taps to toggle — verify current state`;
+        case 'locatorUncheck':
+            return `${el}.click()  # uncheck: taps to toggle — verify current state`;
+        case 'locatorFocus':
+            return `${el}.click()  # focus`;
+        case 'assertVisible':
+            return `${PY_WAIT}(EC.visibility_of_element_located(${tuple}))`;
+        case 'assertHidden':
+            return `${PY_WAIT}(EC.invisibility_of_element_located(${tuple}))`;
+        case 'assertAttached':
+            return `${PY_WAIT}(EC.presence_of_element_located(${tuple}))`;
+        case 'assertEnabled':
+            return `${PY_WAIT}(EC.element_to_be_clickable(${tuple}))`;
+        case 'assertDisabled':
+            return `assert not ${el}.is_enabled()`;
+        case 'assertText':
+            return a.mode === 'contains'
+                ? `${PY_WAIT}(EC.text_to_be_present_in_element(${tuple}, ${str(a.expected)}))`
+                : `${PY_WAIT}(lambda d: d.find_element${tuple}.text == ${str(a.expected)})`;
+        case 'assertValue':
+            return `${PY_WAIT}(lambda d: d.find_element${tuple}.get_attribute("value") == ${str(a.expected)})`;
+        case 'assertEmpty':
+            return `${PY_WAIT}(lambda d: d.find_element${tuple}.text == "")`;
+        case 'assertChecked':
+            return `assert ${el}.get_attribute("checked") == "true"`;
+        case 'assertUnchecked':
+            return `assert ${el}.get_attribute("checked") != "true"`;
+        case 'assertCount':
+            return `${PY_WAIT}(lambda d: len(d.find_elements${tuple}) == ${a.expected})`;
+        case 'assertAttribute':
+            return `assert ${el}.get_attribute(${str(a.name)}) == ${str(a.expected)}`;
+        default:
+            return pyTodo(a);
+    }
+}
+function renderJava(a) {
+    switch (a.kind) {
+        case 'comment':
+            return `// ${a.text}`;
+        case 'sendKeys':
+            return `driver.executeScript("mobile: type", java.util.Map.of("text", ${str(a.text)}));`;
+        case 'switchContext':
+            return /^NATIVE_APP$/i.test(a.context)
+                ? `((io.appium.java_client.remote.SupportsContextSwitching) driver).context("NATIVE_APP");`
+                : `((io.appium.java_client.remote.SupportsContextSwitching) driver).context(${str(a.context)});  // NOTE: WebView handles vary across runs`;
+        case 'tap':
+        case 'swipe':
+        case 'screenScroll':
+            return javaTodo(a);
+        default:
+            break;
+    }
+    const leaf = leafOf(a);
+    if (!leaf)
+        return javaTodo(a);
+    const el = javaElement(leaf);
+    const by = javaBy(leaf);
+    if (!el || !by)
+        return javaTodo(a);
+    switch (a.kind) {
+        case 'locatorClick':
+            return `${el}.click();`;
+        case 'locatorFill':
+            return `${el}.sendKeys(${str(a.text)});`;
+        case 'locatorClear':
+            return `${el}.clear();`;
+        case 'locatorPressSequentially':
+            return `${el}.sendKeys(${str(a.text)});${a.delay ? '  // delay not supported by sendKeys' : ''}`;
+        case 'locatorCheck':
+            return `${el}.click();  // check: taps to toggle — verify current state`;
+        case 'locatorUncheck':
+            return `${el}.click();  // uncheck: taps to toggle — verify current state`;
+        case 'locatorFocus':
+            return `${el}.click();  // focus`;
+        case 'assertVisible':
+            return `${JAVA_WAIT}(ExpectedConditions.visibilityOfElementLocated(${by}));`;
+        case 'assertHidden':
+            return `${JAVA_WAIT}(ExpectedConditions.invisibilityOfElementLocated(${by}));`;
+        case 'assertAttached':
+            return `${JAVA_WAIT}(ExpectedConditions.presenceOfElementLocated(${by}));`;
+        case 'assertEnabled':
+            return `${JAVA_WAIT}(ExpectedConditions.elementToBeClickable(${by}));`;
+        case 'assertDisabled':
+            return `org.junit.jupiter.api.Assertions.assertFalse(${el}.isEnabled());`;
+        case 'assertText':
+            return a.mode === 'contains'
+                ? `${JAVA_WAIT}(ExpectedConditions.textToBePresentInElementLocated(${by}, ${str(a.expected)}));`
+                : `${JAVA_WAIT}(d -> d.findElement(${by}).getText().equals(${str(a.expected)}));`;
+        case 'assertValue':
+            return `${JAVA_WAIT}(d -> ${str(a.expected)}.equals(d.findElement(${by}).getAttribute("value")));`;
+        case 'assertEmpty':
+            return `${JAVA_WAIT}(d -> d.findElement(${by}).getText().isEmpty());`;
+        case 'assertChecked':
+            return `org.junit.jupiter.api.Assertions.assertEquals("true", ${el}.getAttribute("checked"));`;
+        case 'assertUnchecked':
+            return `org.junit.jupiter.api.Assertions.assertNotEquals("true", ${el}.getAttribute("checked"));`;
+        case 'assertCount':
+            return `${JAVA_WAIT}(d -> d.findElements(${by}).size() == ${a.expected});`;
+        case 'assertAttribute':
+            return `org.junit.jupiter.api.Assertions.assertEquals(${str(a.expected)}, ${el}.getAttribute(${str(a.name)}));`;
+        default:
+            return javaTodo(a);
+    }
+}
+const EMPTY_PY = '# (no actions recorded yet — interact with the device in the inspector)';
+const EMPTY_JAVA = '// (no actions recorded yet — interact with the device in the inspector)';
+export function toStepsPython(actions) {
+    if (actions.length === 0)
+        return EMPTY_PY + '\n';
+    return actions.map(renderPy).join('\n') + '\n';
+}
+export function toStepsJava(actions) {
+    if (actions.length === 0)
+        return EMPTY_JAVA + '\n';
+    return actions.map(renderJava).join('\n') + '\n';
+}

package/dist/inspector/devices.d.ts

@@ -0,0 +1,41 @@
+export type DeviceState = 'booted' | 'shutdown' | 'booting' | 'unknown';
+export interface Device {
+    type: 'android' | 'ios';
+    udid: string;
+    name: string;
+    osVersion?: string;
+    state: DeviceState;
+    avdName?: string;
+    runtime?: string;
+    bootable?: boolean;
+    bootHint?: string;
+}
+export interface DeviceListing {
+    android: Device[];
+    ios: Device[];
+    toolsMissing: {
+        adb?: boolean;
+        emulator?: boolean;
+        xcrun?: boolean;
+    };
+}
+export declare function listDevices(): Promise<DeviceListing>;
+export declare function annotateAndroidBootability(devices: Device[]): Promise<Device[]>;
+export declare function startAndroidEmulator(avdName: string): Promise<void>;
+export declare function stopAndroidEmulator(serial: string): Promise<void>;
+export declare function findSerialForAvd(online: Map<string, {
+    avdName?: string;
+}>, avdName: string): string | undefined;
+export declare function ensureAndroidAvdReady(avdName: string, opts?: {
+    timeoutMs?: number;
+}): Promise<string>;
+export declare function waitForAndroidDeviceReady(serial: string, opts?: {
+    timeoutMs?: number;
+}): Promise<boolean>;
+export declare function resolveAndroidSerial(opts: {
+    udid?: string;
+    avdName?: string;
+}): Promise<string | undefined>;
+export declare function isTransientDeviceError(message: string): boolean;
+export declare function startIosSimulator(udid: string): Promise<void>;
+export declare function stopIosSimulator(udid: string): Promise<void>;