@taqwright/taqwright 0.0.24

package/dist/doctor.js

@@ -0,0 +1,508 @@
+import { spawn } from 'node:child_process';
+import { existsSync, promises as fs } from 'node:fs';
+import path from 'node:path';
+import { applyManagedEnv, readManifest } from './setup/paths.js';
+import { spawnTool } from './setup/spawn-tool.js';
+import { avdHomeDir, isAvdImageInstalled, readAvdSystemImage } from './setup/avd.js';
+export { normalizeSysImagePath } from './setup/avd.js';
+export async function runDoctorChecks() {
+    applyManagedEnv();
+    const checks = [];
+    checks.push({
+        name: 'Node.js 24.x–25.x',
+        status: isNodeVersionSupported(process.versions.node) ? 'ok' : 'error',
+        detail: isNodeVersionSupported(process.versions.node)
+            ? process.version
+            : `${process.version} — taqwright requires Node.js 24 or 25 (Node 26+ has a known bug)`,
+    });
+    const adb = await commandExists('adb');
+    checks.push({
+        name: 'adb (Android SDK)',
+        status: adb ? 'ok' : 'warn',
+        detail: adb ? 'on PATH' : 'not found — Android tests will not work',
+    });
+    checks.push(checkAndroidHome());
+    const avdImagesCheck = await checkManagedSdkAvdImages();
+    if (avdImagesCheck)
+        checks.push(avdImagesCheck);
+    if (process.platform === 'darwin') {
+        const xcrun = await commandExists('xcrun');
+        checks.push({
+            name: 'xcrun (Xcode CLT)',
+            status: xcrun ? 'ok' : 'warn',
+            detail: xcrun ? 'on PATH' : 'not found — iOS tests will not work',
+        });
+        if (xcrun) {
+            const devDir = (await readCommandOutput('xcode-select', ['-p']))?.trim();
+            if (!devDir) {
+                checks.push({
+                    name: 'Xcode (full, for XCUITest)',
+                    status: 'warn',
+                    detail: 'xcode-select path not set — run `sudo xcode-select --switch ' +
+                        '/Applications/Xcode.app/Contents/Developer`',
+                });
+            }
+            else if (/CommandLineTools/.test(devDir)) {
+                checks.push({
+                    name: 'Xcode (full, for XCUITest)',
+                    status: 'warn',
+                    detail: `Command Line Tools only (${devDir}) — XCUITest needs full Xcode. ` +
+                        'Run `sudo xcode-select --switch /Applications/Xcode.app/Contents/Developer`',
+                });
+            }
+            else {
+                const xb = await readCommandOutput('xcodebuild', ['-version']);
+                const ver = xb?.match(/Xcode\s+([\d.]+)/);
+                if (ver) {
+                    checks.push({
+                        name: 'Xcode (full, for XCUITest)',
+                        status: 'ok',
+                        detail: `Xcode ${ver[1]} (${devDir})`,
+                    });
+                }
+                else if (xb && /license/i.test(xb)) {
+                    checks.push({
+                        name: 'Xcode (full, for XCUITest)',
+                        status: 'warn',
+                        detail: 'Xcode license not accepted — run `sudo xcodebuild -license accept`',
+                    });
+                }
+                else {
+                    checks.push({
+                        name: 'Xcode (full, for XCUITest)',
+                        status: 'warn',
+                        detail: `xcodebuild not usable (${devDir}) — check the Xcode install`,
+                    });
+                }
+            }
+        }
+        const ffmpeg = await commandExists('ffmpeg');
+        checks.push({
+            name: 'ffmpeg (iOS-sim video)',
+            status: ffmpeg ? 'ok' : 'warn',
+            detail: ffmpeg
+                ? 'on PATH'
+                : 'not found — optional; only needed for iOS-simulator screen recording (video)',
+        });
+        const networksetup = await commandExists('networksetup');
+        checks.push({
+            name: 'networksetup (iOS-sim network capture)',
+            status: networksetup ? 'ok' : 'warn',
+            detail: networksetup
+                ? 'on PATH'
+                : 'not found — optional; only needed for iOS-simulator network capture (network)',
+        });
+        if (xcrun) {
+            const simJson = await readCommandOutput('xcrun', [
+                'simctl',
+                'list',
+                'devices',
+                'available',
+                '--json',
+            ]);
+            if (simJson === undefined) {
+                checks.push({
+                    name: 'iOS simulator (WDA target)',
+                    status: 'warn',
+                    detail: 'could not query `xcrun simctl list devices available`',
+                });
+            }
+            else {
+                let count = 0;
+                let latest;
+                let latestScore = -1;
+                try {
+                    const slice = simJson.slice(simJson.indexOf('{'), simJson.lastIndexOf('}') + 1);
+                    const parsed = JSON.parse(slice);
+                    for (const [runtime, entries] of Object.entries(parsed.devices ?? {})) {
+                        const m = runtime.match(/iOS-(\d+)-(\d+)/);
+                        if (!m)
+                            continue;
+                        const usable = (entries ?? []).filter((e) => e.isAvailable !== false);
+                        if (usable.length === 0)
+                            continue;
+                        count += usable.length;
+                        const score = Number(m[1]) * 1000 + Number(m[2]);
+                        if (score > latestScore) {
+                            latestScore = score;
+                            latest = `${m[1]}.${m[2]}`;
+                        }
+                    }
+                }
+                catch {
+                }
+                if (count > 0) {
+                    checks.push({
+                        name: 'iOS simulator (WDA target)',
+                        status: 'ok',
+                        detail: `${count} available${latest ? ` (latest iOS ${latest})` : ''}`,
+                    });
+                }
+                else {
+                    checks.push({
+                        name: 'iOS simulator (WDA target)',
+                        status: 'warn',
+                        detail: 'none available — WebDriverAgent has no build destination ' +
+                            '(:8100 ECONNREFUSED). Install one: `xcodebuild -downloadPlatform iOS` ' +
+                            '(Xcode → Settings → Components).',
+                    });
+                }
+            }
+        }
+    }
+    const forgeOk = await canImport('node-forge');
+    checks.push({
+        name: 'node-forge (network capture)',
+        status: forgeOk ? 'ok' : 'warn',
+        detail: forgeOk ? 'loaded' : 'failed to import — reinstall dependencies (`npm install`)',
+    });
+    const java = await commandExists('java');
+    if (!java) {
+        checks.push({
+            name: 'java (JDK for UiAutomator2)',
+            status: 'warn',
+            detail: 'not found — Appium Android driver may fail',
+        });
+    }
+    else {
+        const jver = await readJavaVersion();
+        const level = jver ? classifyJdkVersion(jver) : 'unknown';
+        checks.push({
+            name: 'java (JDK for UiAutomator2)',
+            status: level === 'ok' ? 'ok' : 'warn',
+            detail: level === 'ok'
+                ? `on PATH (v${jver})`
+                : level === 'too-old'
+                    ? `v${jver} is too old — Appium/UiAutomator2 + Android build-tools need JDK ${MIN_JDK_MAJOR}+`
+                    : 'on PATH but version could not be read',
+        });
+    }
+    checks.push(checkJavaHome());
+    const appium = await commandExists('appium');
+    if (!appium) {
+        checks.push({
+            name: 'Appium (test server)',
+            status: 'warn',
+            detail: 'not found — install with `npm i -g appium@^3` then `appium driver install uiautomator2`',
+        });
+    }
+    else {
+        const version = await readCommandVersion('appium');
+        if (!version) {
+            checks.push({
+                name: 'Appium (test server)',
+                status: 'warn',
+                detail: 'on PATH but version could not be read',
+            });
+        }
+        else {
+            const level = classifyAppiumVersion(version);
+            if (level === 'recommended') {
+                checks.push({
+                    name: 'Appium (test server)',
+                    status: 'ok',
+                    detail: `on PATH (v${version})`,
+                });
+            }
+            else if (level === 'best-effort') {
+                checks.push({
+                    name: 'Appium (test server)',
+                    status: 'warn',
+                    detail: `Appium 2.x detected (v${version}) — best-effort, not officially tested. ` +
+                        'Upgrade for the supported path: `npm i -g appium@^3`.',
+                });
+            }
+            else {
+                checks.push({
+                    name: 'Appium (test server)',
+                    status: 'error',
+                    detail: `v${version} is not supported — taqwright targets Appium 3.x ` +
+                        '(2.x runs best-effort). Upgrade with `npm i -g appium@^3`.',
+                });
+            }
+        }
+    }
+    if (appium) {
+        const driverOut = await readCommandOutput('appium', ['driver', 'list', '--installed']);
+        if (driverOut === undefined) {
+            checks.push({
+                name: 'Appium drivers',
+                status: 'warn',
+                detail: 'could not query `appium driver list --installed`',
+            });
+        }
+        else {
+            const hasUia2 = /uiautomator2/.test(driverOut);
+            const hasXcui = /xcuitest/.test(driverOut);
+            if (!hasUia2 && !hasXcui) {
+                checks.push({
+                    name: 'Appium drivers',
+                    status: 'warn',
+                    detail: 'no platform driver installed — `appium driver install uiautomator2` ' +
+                        '(Android) and/or `appium driver install xcuitest` (iOS)',
+                });
+            }
+            else {
+                const installed = [hasUia2 ? 'uiautomator2' : undefined, hasXcui ? 'xcuitest' : undefined]
+                    .filter(Boolean)
+                    .join(', ');
+                const missing = [];
+                if (!hasUia2)
+                    missing.push('uiautomator2 (Android) `appium driver install uiautomator2`');
+                if (!hasXcui)
+                    missing.push('xcuitest (iOS) `appium driver install xcuitest`');
+                checks.push({
+                    name: 'Appium drivers',
+                    status: 'ok',
+                    detail: missing.length ? `${installed}; not installed: ${missing.join('; ')}` : installed,
+                });
+            }
+        }
+    }
+    return checks;
+}
+function checkJavaHome() {
+    const name = 'JAVA_HOME (UiAutomator2 JDK)';
+    const home = process.env.JAVA_HOME;
+    if (!home) {
+        return {
+            name,
+            status: 'warn',
+            detail: "unset — Appium's UiAutomator2 driver may not find the JDK. Export " +
+                'JAVA_HOME (e.g. `$(/usr/libexec/java_home -v 21)` on macOS) in the ' +
+                'shell that launches taqwright.',
+        };
+    }
+    if (!existsSync(home)) {
+        return { name, status: 'warn', detail: `set to ${home} but that directory does not exist` };
+    }
+    const javaBin = path.join(home, 'bin', process.platform === 'win32' ? 'java.exe' : 'java');
+    if (!existsSync(javaBin)) {
+        return {
+            name,
+            status: 'warn',
+            detail: `set to ${home} but ${path.join('bin', 'java')} is missing — not a JDK home`,
+        };
+    }
+    return { name, status: 'ok', detail: `JAVA_HOME=${home}` };
+}
+function checkAndroidHome() {
+    const name = 'ANDROID_HOME (Appium adb lookup)';
+    const home = process.env.ANDROID_HOME || process.env.ANDROID_SDK_ROOT;
+    if (!home) {
+        return {
+            name,
+            status: 'warn',
+            detail: 'unset — Appium will not find adb. Export ANDROID_HOME (e.g. `~/Library/Android/sdk`) ' +
+                'in the shell that launches taqwright.',
+        };
+    }
+    if (!existsSync(home)) {
+        return {
+            name,
+            status: 'warn',
+            detail: `set to ${home} but that directory does not exist`,
+        };
+    }
+    const adbBin = path.join(home, 'platform-tools', process.platform === 'win32' ? 'adb.exe' : 'adb');
+    if (!existsSync(adbBin)) {
+        return {
+            name,
+            status: 'warn',
+            detail: `set to ${home} but ${path.join('platform-tools', 'adb')} is missing — install Android SDK platform-tools`,
+        };
+    }
+    const source = process.env.ANDROID_HOME ? 'ANDROID_HOME' : 'ANDROID_SDK_ROOT';
+    return { name, status: 'ok', detail: `${source}=${home}` };
+}
+async function canImport(name) {
+    try {
+        await import(name);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function checkManagedSdkAvdImages() {
+    if (!readManifest())
+        return undefined;
+    const androidHome = process.env.ANDROID_HOME;
+    if (!androidHome)
+        return undefined;
+    const avdHome = avdHomeDir();
+    if (!existsSync(avdHome))
+        return undefined;
+    let entries;
+    try {
+        entries = await fs.readdir(avdHome);
+    }
+    catch {
+        return undefined;
+    }
+    const avdNames = entries
+        .filter((name) => name.endsWith('.avd'))
+        .map((name) => name.slice(0, -'.avd'.length));
+    if (avdNames.length === 0)
+        return undefined;
+    const missing = [];
+    let total = 0;
+    for (const avdName of avdNames) {
+        const image = await readAvdSystemImage(avdName, avdHome);
+        if (image === undefined)
+            continue;
+        total++;
+        if (!isAvdImageInstalled(image, androidHome)) {
+            missing.push({ avd: avdName, image });
+        }
+    }
+    if (missing.length === 0) {
+        return {
+            name: 'Managed SDK AVD images',
+            status: 'ok',
+            detail: `${total} AVD${total === 1 ? '' : 's'} found, all system images present`,
+        };
+    }
+    const list = missing.map((m) => `${m.avd} → ${m.image}`).join('; ');
+    const sdkmanagerCmds = missing.map((m) => `sdkmanager "${m.image.replace(/\//g, ';')}"`);
+    return {
+        name: 'Managed SDK AVD images',
+        status: 'warn',
+        detail: `${missing.length} AVD${missing.length === 1 ? '' : 's'} reference a system image not in the managed SDK: ${list}. ` +
+            `taqwright auto-boots such an AVD against your system SDK when the image is present there; ` +
+            `otherwise fix one of: (a) install the missing image into the managed SDK — \`${sdkmanagerCmds[0]}\` ` +
+            `(uses \`${path.join(androidHome, 'cmdline-tools', 'latest', 'bin', 'sdkmanager')}\`); ` +
+            `(b) bypass the managed toolchain — \`rm ${path.join(path.dirname(androidHome), 'manifest.json')}\` ` +
+            `(falls back to your shell ANDROID_HOME); ` +
+            `(c) recreate the AVD against an image present in the managed SDK.`,
+    };
+}
+async function commandExists(name) {
+    return new Promise((resolve) => {
+        const child = spawn(process.platform === 'win32' ? 'where' : 'which', [name], {
+            stdio: 'ignore',
+        });
+        child.on('exit', (code) => resolve(code === 0));
+        child.on('error', () => resolve(false));
+    });
+}
+async function readCommandVersion(cmd) {
+    return new Promise((resolve) => {
+        const child = spawnTool(cmd, ['--version'], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let out = '';
+        child.stdout?.on('data', (chunk) => {
+            out += String(chunk);
+        });
+        child.stderr?.on('data', (chunk) => {
+            out += String(chunk);
+        });
+        child.on('exit', () => {
+            const m = out.match(/(\d+)\.(\d+)\.(\d+)(?:-[\w.]+)?/);
+            resolve(m ? m[0] : undefined);
+        });
+        child.on('error', () => resolve(undefined));
+    });
+}
+async function readCommandOutput(cmd, args) {
+    return new Promise((resolve) => {
+        const child = spawnTool(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+        let out = '';
+        child.stdout?.on('data', (chunk) => {
+            out += String(chunk);
+        });
+        child.stderr?.on('data', (chunk) => {
+            out += String(chunk);
+        });
+        child.on('exit', () => resolve(out));
+        child.on('error', () => resolve(undefined));
+    });
+}
+export function classifyAppiumVersion(version) {
+    const m = version.match(/^(\d+)\./);
+    if (!m)
+        return 'unsupported';
+    const major = Number(m[1]);
+    if (!Number.isFinite(major))
+        return 'unsupported';
+    if (major >= 3)
+        return 'recommended';
+    if (major === 2)
+        return 'best-effort';
+    return 'unsupported';
+}
+const MIN_JDK_MAJOR = 17;
+export function classifyJdkVersion(version) {
+    const m = version.match(/(\d+)(?:\.(\d+))?/);
+    if (!m)
+        return 'unknown';
+    let major = Number(m[1]);
+    if (major === 1 && m[2])
+        major = Number(m[2]);
+    if (!Number.isFinite(major))
+        return 'unknown';
+    return major >= MIN_JDK_MAJOR ? 'ok' : 'too-old';
+}
+export function androidToolchainReady(s) {
+    return s.jdk === 'ok' && s.sdk && s.appium === 'recommended' && s.uiautomator2;
+}
+async function readJavaVersion() {
+    const out = await readCommandOutput('java', ['-version']);
+    return out?.match(/version "([^"]+)"/)?.[1];
+}
+export async function listAvds() {
+    try {
+        const entries = await fs.readdir(avdHomeDir());
+        return entries.filter((e) => e.endsWith('.ini')).map((e) => e.slice(0, -'.ini'.length));
+    }
+    catch {
+        return [];
+    }
+}
+export async function detectAndroidToolchain() {
+    applyManagedEnv();
+    const [jdkPresent, sdk, appiumPresent] = await Promise.all([
+        commandExists('java'),
+        commandExists('adb'),
+        commandExists('appium'),
+    ]);
+    let jdk = 'missing';
+    let jdkVersion;
+    if (jdkPresent) {
+        jdkVersion = await readJavaVersion();
+        jdk = jdkVersion ? classifyJdkVersion(jdkVersion) : 'unknown';
+    }
+    let appium = 'missing';
+    let appiumVersion;
+    let uiautomator2 = false;
+    if (appiumPresent) {
+        appiumVersion = await readCommandVersion('appium');
+        appium = appiumVersion ? classifyAppiumVersion(appiumVersion) : 'unsupported';
+        const drivers = await readCommandOutput('appium', ['driver', 'list', '--installed']);
+        uiautomator2 = drivers !== undefined && /uiautomator2/.test(drivers);
+    }
+    const avdNames = await listAvds();
+    return {
+        jdk,
+        jdkVersion,
+        sdk,
+        appium,
+        appiumVersion,
+        uiautomator2,
+        avd: avdNames.length > 0,
+        avdNames,
+        ready: androidToolchainReady({ jdk, sdk, appium, uiautomator2 }),
+    };
+}
+export function isAppiumVersionSupported(version) {
+    const level = classifyAppiumVersion(version);
+    return level === 'recommended' || level === 'best-effort';
+}
+export function isNodeVersionSupported(version) {
+    const m = version.match(/^v?(\d+)\./);
+    if (!m)
+        return false;
+    const major = Number(m[1]);
+    return Number.isFinite(major) && major >= 24 && major < 26;
+}

package/dist/expect.d.ts

@@ -0,0 +1,38 @@
+import { expect as pwExpect } from '@playwright/test';
+import { Locator } from './locator/index.js';
+interface TimeoutOptions {
+    timeout?: number;
+}
+interface VisibleOptions extends TimeoutOptions {
+    visible?: boolean;
+}
+interface EnabledOptions extends TimeoutOptions {
+    enabled?: boolean;
+}
+interface CheckedOptions extends TimeoutOptions {
+    checked?: boolean;
+}
+interface EditableOptions extends TimeoutOptions {
+    editable?: boolean;
+}
+export interface MobileMatchers {
+    toBeVisible(options?: VisibleOptions): Promise<void>;
+    toBeHidden(options?: TimeoutOptions): Promise<void>;
+    toBeEnabled(options?: EnabledOptions): Promise<void>;
+    toBeDisabled(options?: TimeoutOptions): Promise<void>;
+    toBeChecked(options?: CheckedOptions): Promise<void>;
+    toBeEditable(options?: EditableOptions): Promise<void>;
+    toBeFocused(options?: TimeoutOptions): Promise<void>;
+    toBeAttached(options?: TimeoutOptions): Promise<void>;
+    toBeInViewport(options?: TimeoutOptions): Promise<void>;
+    toBeEmpty(options?: TimeoutOptions): Promise<void>;
+    toHaveText(expected: string | RegExp, options?: TimeoutOptions): Promise<void>;
+    toContainText(expected: string, options?: TimeoutOptions): Promise<void>;
+    toHaveValue(value: string | RegExp, options?: TimeoutOptions): Promise<void>;
+    toHaveCount(count: number, options?: TimeoutOptions): Promise<void>;
+    toHaveAttribute(name: string, value: string | RegExp, options?: TimeoutOptions): Promise<void>;
+    readonly not: MobileMatchers;
+}
+export type TaqwrightExpect = ((actual: Locator, message?: string) => MobileMatchers) & typeof pwExpect;
+export declare const expect: TaqwrightExpect;
+export {};

package/dist/expect.js

@@ -0,0 +1,96 @@
+import { expect as pwExpect } from '@playwright/test';
+import { Locator } from './locator/index.js';
+const WEB_ONLY_MATCHERS = [
+    'toHaveClass',
+    'toContainClass',
+    'toHaveCSS',
+    'toHaveId',
+    'toHaveJSProperty',
+    'toHaveValues',
+    'toHaveRole',
+    'toHaveAccessibleName',
+    'toHaveAccessibleDescription',
+    'toHaveAccessibleErrorMessage',
+    'toHaveScreenshot',
+    'toMatchAriaSnapshot',
+    'toHaveTitle',
+    'toHaveURL',
+    'toBeOK',
+];
+const UNSUPPORTED_OPTION_KEYS = ['ignoreCase', 'useInnerText', 'ratio', 'indeterminate'];
+function actionOpts(o) {
+    for (const key of UNSUPPORTED_OPTION_KEYS) {
+        if (o && key in o) {
+            throw new Error(`expect(locator): option "${key}" is not supported on mobile locators`);
+        }
+    }
+    return o?.timeout === undefined ? undefined : { timeout: o.timeout };
+}
+function makeMobileMatchers(loc, negated, message) {
+    const run = async (fn) => {
+        try {
+            await fn();
+        }
+        catch (err) {
+            if (message) {
+                const detail = err instanceof Error ? err.message : String(err);
+                throw new Error(`${message}\n${detail}`, { cause: err });
+            }
+            throw err;
+        }
+    };
+    const unsupportedNot = (matcher) => {
+        throw new Error(`expect(locator).not.${matcher}() is not supported on mobile locators — ` +
+            `use the positive form or locator.assert*() directly`);
+    };
+    const matchers = {
+        toBeVisible: (o) => {
+            const want = (o?.visible ?? true) !== negated;
+            return run(() => (want ? loc.assertVisible(actionOpts(o)) : loc.assertHidden(actionOpts(o))));
+        },
+        toBeHidden: (o) => run(() => (negated ? loc.assertVisible(actionOpts(o)) : loc.assertHidden(actionOpts(o)))),
+        toBeEnabled: (o) => {
+            const want = (o?.enabled ?? true) !== negated;
+            return run(() => want ? loc.assertEnabled(actionOpts(o)) : loc.assertDisabled(actionOpts(o)));
+        },
+        toBeDisabled: (o) => run(() => (negated ? loc.assertEnabled(actionOpts(o)) : loc.assertDisabled(actionOpts(o)))),
+        toBeChecked: (o) => {
+            const want = (o?.checked ?? true) !== negated;
+            return run(() => want ? loc.assertChecked(actionOpts(o)) : loc.assertUnchecked(actionOpts(o)));
+        },
+        toBeEditable: (o) => {
+            const want = (o?.editable ?? true) !== negated;
+            return run(() => want ? loc.assertEditable(actionOpts(o)) : loc.assertReadonly(actionOpts(o)));
+        },
+        toBeFocused: (o) => negated ? unsupportedNot('toBeFocused') : run(() => loc.assertFocused(actionOpts(o))),
+        toBeAttached: (o) => negated ? unsupportedNot('toBeAttached') : run(() => loc.assertAttached(actionOpts(o))),
+        toBeInViewport: (o) => negated ? unsupportedNot('toBeInViewport') : run(() => loc.assertInViewport(actionOpts(o))),
+        toBeEmpty: (o) => negated ? unsupportedNot('toBeEmpty') : run(() => loc.assertEmpty(actionOpts(o))),
+        toHaveText: (expected, o) => negated ? unsupportedNot('toHaveText') : run(() => loc.assertText(expected, actionOpts(o))),
+        toContainText: (expected, o) => negated
+            ? unsupportedNot('toContainText')
+            : run(() => loc.assertContainsText(expected, actionOpts(o))),
+        toHaveValue: (value, o) => negated ? unsupportedNot('toHaveValue') : run(() => loc.assertValue(value, actionOpts(o))),
+        toHaveCount: (count, o) => negated ? unsupportedNot('toHaveCount') : run(() => loc.assertCount(count, actionOpts(o))),
+        toHaveAttribute: (name, value, o) => negated
+            ? unsupportedNot('toHaveAttribute')
+            : run(() => loc.assertAttribute(name, value, actionOpts(o))),
+        get not() {
+            return makeMobileMatchers(loc, !negated, message);
+        },
+    };
+    for (const name of WEB_ONLY_MATCHERS) {
+        matchers[name] = () => {
+            throw new Error(`${name}() is not supported on mobile locators`);
+        };
+    }
+    return matchers;
+}
+const expectImpl = ((actual, message) => {
+    if (actual instanceof Locator) {
+        return makeMobileMatchers(actual, false, message);
+    }
+    return pwExpect(actual, message);
+});
+Object.assign(expectImpl, pwExpect);
+export const expect = expectImpl;

package/dist/fixture/artifact-mode.d.ts

@@ -0,0 +1,2 @@
+export type ArtifactMode = 'off' | 'on' | 'on-failure' | 'retain-on-failure';
+export declare function shouldRetainArtifact(mode: ArtifactMode, failed: boolean): boolean;

package/dist/fixture/artifact-mode.js

@@ -0,0 +1,7 @@
+export function shouldRetainArtifact(mode, failed) {
+    if (mode === 'on')
+        return true;
+    if (mode === 'on-failure' || mode === 'retain-on-failure')
+        return failed;
+    return false;
+}

package/dist/fixture/index.d.ts

@@ -0,0 +1,15 @@
+import type { Client as WebDriverClient } from 'webdriver';
+import { Mobile } from '../mobile/index.js';
+import { type DeviceProvider, type TaqwrightUseOptions } from '../types/index.js';
+import { type NetworkProxyHandle } from '../network/index.js';
+interface TaqwrightFixtures {
+    mobile: Mobile;
+    rawDriver: WebDriverClient;
+    networkProxy: NetworkProxyHandle | null;
+}
+interface TaqwrightWorkerFixtures {
+    taqwrightUse: TaqwrightUseOptions;
+    deviceProvider: DeviceProvider | null;
+}
+export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & TaqwrightFixtures, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions & TaqwrightWorkerFixtures>;
+export {};