@leera.io/qa-runner 1.0.0

package/dist/src/drivers/tauri-webdriver.js

@@ -0,0 +1,678 @@
+import { spawn } from 'node:child_process';
+import { connect, createServer } from 'node:net';
+import { dirname } from 'node:path';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { disposeUnpacked } from '../builds/cleanup.js';
+import { AppNotAvailable, resolveAppFile } from '../builds/install.js';
+import { buildKind, DesktopBuildError, localDesktopApp, unpackDesktopBuild } from '../builds/unpack.js';
+import { ensureDisplay, hostDevice } from '../devices/desktop.js';
+import { loadTauriSettings, MACOS_PLUGIN_BLOCKED, tauriBackend, tauriCapabilities, tauriDriverArgv, } from '../devices/tauri.js';
+import { homePaths } from '../home.js';
+import { LOCAL_PATHS_REFUSED } from './android-appium.js';
+import { clip, errorMessage, expectWithin, matches, render, requireTarget, verb } from './common.js';
+import { Blocked, LaunchRefused, NotFound, Unsupported, } from './driver.js';
+import { ELECTRON_ACTIONS, electronEnv, killProcessTree, validateElectronAction } from './electron-playwright.js';
+import { DOM_LOCATORS, describeDomTarget, domCandidates, domFindAll, domLocate, domLocateOnce, domScript, elementRef, keyActions, validateDomTarget, webdriverKeys, } from './webdriver/dom.js';
+import { buildDomSnapshot, domRefOf, domScreen } from './webdriver/dom-tree.js';
+import { elementIdOf } from './webdriver/locate.js';
+import { openSession, webdriverMessage } from './webdriver/session.js';
+/** Tauri DSL (contracts §L): the electron actions; locators css, text, test_id, xpath. */
+export const TAURI_ACTIONS = [...ELECTRON_ACTIONS];
+export const TAURI_TARGETS = [...DOM_LOCATORS];
+export const TAURI_INSTALLED_REFUSED = 'tauri apps need an uploaded build or a path on the runner';
+export const MSI_REFUSED = 'an .msi installer cannot run in place — upload the portable .exe or a zip of the installed app folder';
+export const DEB_REFUSED = 'a .deb package cannot run in place — upload the .AppImage or a zip of the installed app folder';
+/** How long a macOS plugin build has to answer `GET /status` (contracts §L). */
+export const PLUGIN_STATUS_TIMEOUT_MS = 30_000;
+const DRIVER_START_TIMEOUT_MS = 20_000;
+const SESSION_TIMEOUT_MS = 120_000;
+const PAGE_READY_TIMEOUT_MS = 30_000;
+/** Checks a Tauri action before it runs; throws what the step reports. */
+export function validateTauriAction(action) {
+    if (action.type === 'goto')
+        throw new Unsupported("'goto' is not a tauri action; start the app with launch");
+    if (action.type === 'launch' || action.type === 'focus_window')
+        validateElectronAction(action);
+    if (action.target)
+        validateDomTarget(action.target);
+}
+/** Why a build file cannot run as a Tauri app, or null (installers are refused, contracts §L). */
+export function tauriBuildRefusal(fileName) {
+    const lower = fileName.toLowerCase();
+    if (lower.endsWith('.msi'))
+        return MSI_REFUSED;
+    if (lower.endsWith('.deb'))
+        return DEB_REFUSED;
+    return null;
+}
+/** The environment a macOS plugin build starts with: the runner's minus secrets, plus the plugin port. */
+export function pluginAppEnv(base, port, extra = {}) {
+    return electronEnv(base, { ...extra, TAURI_WEBDRIVER_PORT: String(port) });
+}
+export function freePort() {
+    return new Promise((resolve, reject) => {
+        const server = createServer();
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address ? address.port : 0;
+            server.close(() => resolve(port));
+        });
+    });
+}
+/**
+ * Polls `GET http://127.0.0.1:<port>/status` until it answers 2xx (true), the app exits or the
+ * time is up (false).
+ */
+export async function waitForPluginStatus(port, options = {}) {
+    const deadline = Date.now() + (options.timeoutMs ?? PLUGIN_STATUS_TIMEOUT_MS);
+    for (;;) {
+        if (options.exited?.())
+            return false;
+        const ok = await fetch(`http://127.0.0.1:${port}/status`, { signal: AbortSignal.timeout(2_000) }).then((response) => response.ok, () => false);
+        if (ok)
+            return true;
+        if (Date.now() >= deadline)
+            return false;
+        await sleep(options.pollMs ?? 250);
+    }
+}
+const defaultOpener = async (url, capabilities, timeoutMs) => (await openSession(url, capabilities, timeoutMs));
+/**
+ * macOS: waits for the embedded plugin's `/status` and attaches a WebDriver session to its
+ * port. An app that never answers is refused with exactly MACOS_PLUGIN_BLOCKED.
+ */
+export async function attachMacosPlugin(port, options = {}) {
+    const reachable = await waitForPluginStatus(port, options);
+    if (!reachable)
+        throw new LaunchRefused(MACOS_PLUGIN_BLOCKED);
+    try {
+        return await (options.open ?? defaultOpener)(`http://127.0.0.1:${port}`, {}, SESSION_TIMEOUT_MS);
+    }
+    catch (error) {
+        throw new Blocked(`the app's WebDriver plugin did not start a session: ${webdriverMessage(error)}`);
+    }
+}
+/** Resolves when something accepts connections on the port, or rejects when the process exits or the time is up. */
+async function waitForPort(port, timeoutMs, exited) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        const failure = exited();
+        if (failure)
+            throw new Error(failure);
+        const open = await new Promise((resolve) => {
+            const socket = connect({ host: '127.0.0.1', port });
+            socket.once('connect', () => {
+                socket.destroy();
+                resolve(true);
+            });
+            socket.once('error', () => resolve(false));
+        });
+        if (open)
+            return;
+        if (Date.now() >= deadline)
+            throw new Error(`nothing listens on port ${port} after ${Math.round(timeoutMs / 1000)} s`);
+        await sleep(150);
+    }
+}
+function track(child, what) {
+    let exit = null;
+    let tail = '';
+    child.stderr?.on('data', (chunk) => {
+        tail = `${tail}${chunk.toString('utf8')}`.slice(-2_000);
+    });
+    child.once('exit', (code, signal) => {
+        exit = `${what} exited (${signal ?? `code ${code}`})`;
+    });
+    child.once('error', (error) => {
+        exit = `${what} could not start: ${error.message}`;
+    });
+    return { child, exited: () => exit, stderr: () => tail.trim().split('\n').pop() ?? '' };
+}
+export class TauriWebDriver {
+    ctx;
+    backend;
+    deps;
+    platform = 'tauri';
+    capabilities = { actions: TAURI_ACTIONS, targets: TAURI_TARGETS, video: 'none' };
+    client = null;
+    driverProcess = null;
+    driverPort = null;
+    app = null;
+    executable = null;
+    unpacked = null;
+    releaseBuild = null;
+    display = null;
+    /** ref → WebDriver element id from the last snapshot. */
+    refElements = new Map();
+    firstLaunchDone = false;
+    actionsRun = 0;
+    disposed = false;
+    constructor(ctx, backend, deps = {}) {
+        this.ctx = ctx;
+        this.backend = backend;
+        this.deps = deps;
+    }
+    get paths() {
+        return this.ctx.paths ?? homePaths(process.env);
+    }
+    get renderText() {
+        return (text) => render(text, this.ctx.template);
+    }
+    /** Where the app comes from: an unpacked build, or an app at a path on this runner. */
+    async resolveExecutable() {
+        const app = this.ctx.job.app;
+        if (!app)
+            throw new LaunchRefused('the job names no Tauri app (set the app in the environment)');
+        const override = app.launch_activity?.trim() || null;
+        if (app.install === 'installed')
+            throw new LaunchRefused(TAURI_INSTALLED_REFUSED);
+        if (app.install === 'path') {
+            if (!this.ctx.allowLocalPaths)
+                throw new LaunchRefused(LOCAL_PATHS_REFUSED);
+            try {
+                return localDesktopApp(app.path ?? '', override);
+            }
+            catch (error) {
+                throw new LaunchRefused(errorMessage(error));
+            }
+        }
+        const refusal = app.build ? tauriBuildRefusal(app.build.file_name) : null;
+        if (refusal)
+            throw new LaunchRefused(refusal);
+        let file;
+        try {
+            const resolved = await resolveAppFile({
+                app,
+                paths: this.paths,
+                allowLocalPaths: this.ctx.allowLocalPaths ?? false,
+                getUrl: (buildId) => {
+                    if (!this.ctx.buildDownloadUrl)
+                        throw new Blocked('this runner cannot download builds for this job');
+                    return this.ctx.buildDownloadUrl(buildId);
+                },
+            });
+            this.releaseBuild = resolved.release;
+            file = resolved.path;
+        }
+        catch (error) {
+            const message = `the app build is not available: ${errorMessage(error)}`;
+            throw error instanceof AppNotAvailable ? new LaunchRefused(message) : new Blocked(message);
+        }
+        if (!file)
+            throw new LaunchRefused(TAURI_INSTALLED_REFUSED);
+        if (buildKind(file) === 'dmg' && this.backend.kind !== 'macos-plugin')
+            throw new LaunchRefused('.dmg builds run on macOS runners only');
+        try {
+            this.unpacked = unpackDesktopBuild(file, override);
+        }
+        catch (error) {
+            const message = `the app build could not be unpacked: ${errorMessage(error)}`;
+            throw error instanceof DesktopBuildError ? new LaunchRefused(message) : new Blocked(message);
+        }
+        return this.unpacked.executable;
+    }
+    async launch() {
+        this.executable = await this.resolveExecutable();
+        try {
+            this.display = await (this.deps.display ?? ensureDisplay)();
+        }
+        catch (error) {
+            throw new Blocked(errorMessage(error));
+        }
+        const first = [...this.ctx.job.automation.steps].sort((a, b) => a.index - b.index)[0]?.actions[0];
+        let args = [];
+        if (first?.type === 'launch') {
+            validateTauriAction(first);
+            args = (first.args ?? []).map(this.renderText);
+            this.firstLaunchDone = true;
+        }
+        await this.start(args);
+    }
+    async start(args) {
+        const executable = this.executable;
+        if (!executable)
+            throw new Blocked('the app was not prepared');
+        if (this.backend.kind === 'macos-plugin')
+            await this.startWithPlugin(executable, args);
+        else
+            await this.startWithTauriDriver(executable, args);
+        await this.waitForPage();
+    }
+    /** Linux/Windows: one tauri-driver per job; each session launches the app. */
+    async startWithTauriDriver(executable, args) {
+        if (this.backend.kind !== 'driver')
+            throw new Blocked('tauri-driver is not available');
+        if (!this.driverProcess || this.driverProcess.exited()) {
+            const port = await freePort();
+            let nativePort = await freePort();
+            while (nativePort === port)
+                nativePort = await freePort();
+            const argv = tauriDriverArgv({
+                port,
+                nativePort,
+                nativeDriver: this.backend.nativeDriver,
+                os: this.backend.os,
+                configuredNative: this.deps.configuredNative ?? false,
+            });
+            const child = (this.deps.spawn ?? spawn)(this.backend.driver, argv, {
+                env: electronEnv(process.env, this.display?.env ?? {}),
+                stdio: ['ignore', 'ignore', 'pipe'],
+                detached: process.platform !== 'win32',
+                windowsHide: true,
+            });
+            const tracked = track(child, 'tauri-driver');
+            this.driverProcess = tracked;
+            this.driverPort = port;
+            try {
+                await waitForPort(port, DRIVER_START_TIMEOUT_MS, tracked.exited);
+            }
+            catch (error) {
+                const detail = tracked.stderr();
+                throw new Blocked(`tauri-driver did not start: ${errorMessage(error)}${detail ? ` (${clip(detail)})` : ''}`);
+            }
+        }
+        try {
+            this.client = await (this.deps.open ?? defaultOpener)(`http://127.0.0.1:${this.driverPort}`, tauriCapabilities(executable, args), SESSION_TIMEOUT_MS);
+        }
+        catch (error) {
+            const detail = this.driverProcess.stderr();
+            throw new Blocked(`the app could not be launched: ${webdriverMessage(error)}${detail ? ` (${clip(detail)})` : ''}`);
+        }
+    }
+    /** macOS: start the app with the plugin port, wait for `/status`, attach. */
+    async startWithPlugin(executable, args) {
+        const port = await freePort();
+        const child = (this.deps.spawn ?? spawn)(executable, args, {
+            cwd: dirname(executable),
+            env: pluginAppEnv(process.env, port, this.display?.env ?? {}),
+            stdio: ['ignore', 'ignore', 'pipe'],
+            detached: process.platform !== 'win32',
+        });
+        this.app = track(child, 'the app');
+        try {
+            this.client = await attachMacosPlugin(port, {
+                ...(this.deps.statusTimeoutMs !== undefined ? { timeoutMs: this.deps.statusTimeoutMs } : {}),
+                exited: this.app.exited,
+                ...(this.deps.open ? { open: this.deps.open } : {}),
+            });
+        }
+        catch (error) {
+            await this.closeApp();
+            throw error;
+        }
+    }
+    /** Waits until the web view runs the runner's script (the page has loaded). */
+    async waitForPage() {
+        const client = this.requireClient();
+        const deadline = Date.now() + PAGE_READY_TIMEOUT_MS;
+        for (;;) {
+            const ready = await client.executeScript(domScript('dom-snapshot'), [{ viewportOnly: true }]).then(() => true, () => false);
+            if (ready || Date.now() >= deadline)
+                return;
+            await sleep(250);
+        }
+    }
+    async run(action) {
+        const first = this.actionsRun === 0;
+        this.actionsRun += 1;
+        validateTauriAction(action);
+        try {
+            switch (action.type) {
+                case 'launch':
+                    if (first && this.firstLaunchDone)
+                        return {};
+                    await this.closeApp();
+                    await this.start((action.args ?? []).map(this.renderText));
+                    return {};
+                case 'terminate':
+                    await this.closeApp();
+                    return {};
+                case 'focus_window':
+                    await this.focusWindow(action);
+                    return {};
+                default:
+                    return await this.runDomAction(action);
+            }
+        }
+        catch (error) {
+            throw this.translate(error);
+        }
+    }
+    /** A lost WebDriver session is an environment problem, not a failed check. */
+    translate(error) {
+        if (error instanceof Blocked || error instanceof NotFound)
+            return error;
+        const message = webdriverMessage(error);
+        if (/invalid session id|no such window|session not created|ECONNREFUSED|ECONNRESET|socket hang up|disconnected/i.test(message)) {
+            return new Blocked(`the app connection was lost: ${message}`);
+        }
+        return error;
+    }
+    requireClient() {
+        if (!this.client)
+            throw new Error('the app is not running; start it with launch');
+        return this.client;
+    }
+    /** The element a target names: a snapshot ref when it still exists, else the locator (waiting up to `timeoutMs`). */
+    async element(target, timeoutMs, visible = true) {
+        const client = this.requireClient();
+        const ref = domRefOf(target.locate);
+        const id = ref ? this.refElements.get(ref) : undefined;
+        if (id) {
+            const displayed = await client.isElementDisplayed(id).then((value) => ({ ok: true, value }), () => ({ ok: false, value: false }));
+            if (displayed.ok)
+                return { elementId: id, target, count: 1, visible: displayed.value };
+        }
+        const { locate: _locate, ...plain } = target;
+        const found = await domLocate(client, plain, timeoutMs, { render: this.renderText, visible });
+        if (!found)
+            throw new NotFound(`${describeDomTarget(plain)} was not found within ${Math.round(timeoutMs / 100) / 10} s`);
+        return found;
+    }
+    /** Whether the target is on screen now (no waiting). */
+    async visibleNow(target) {
+        const client = this.requireClient();
+        const ref = domRefOf(target.locate);
+        const id = ref ? this.refElements.get(ref) : undefined;
+        if (id) {
+            const displayed = await client.isElementDisplayed(id).catch(() => null);
+            if (displayed !== null)
+                return displayed;
+        }
+        const { locate: _locate, ...plain } = target;
+        const found = await domLocateOnce(client, plain, this.renderText);
+        return found?.visible ?? false;
+    }
+    /** Retries an element command while the element is not interactable yet. */
+    async retrying(timeoutMs, target, command) {
+        const deadline = Date.now() + timeoutMs;
+        let found = await this.element(target, timeoutMs);
+        for (;;) {
+            try {
+                await command(found.elementId);
+                return;
+            }
+            catch (error) {
+                const message = webdriverMessage(error);
+                if (Date.now() >= deadline || !/not interactable|intercepted|stale element|not visible|element not/i.test(message))
+                    throw error;
+                await sleep(200);
+                if (/stale element/i.test(message)) {
+                    const { locate: _locate, ...plain } = target;
+                    found = await this.element(plain, Math.max(100, deadline - Date.now()));
+                }
+            }
+        }
+    }
+    async runDomAction(action) {
+        const client = this.requireClient();
+        const timeout = action.timeout_ms ?? this.ctx.timeouts.actionMs;
+        switch (action.type) {
+            case 'click':
+                await this.retrying(timeout, requireTarget(action), (id) => client.elementClick(id));
+                return {};
+            case 'hover': {
+                const found = await this.element(requireTarget(action), timeout);
+                await client.performActions([
+                    { type: 'pointer', id: 'mouse', parameters: { pointerType: 'mouse' }, actions: [{ type: 'pointerMove', duration: 0, origin: elementRef(found.elementId), x: 0, y: 0 }] },
+                ]);
+                return {};
+            }
+            case 'check':
+            case 'uncheck': {
+                const wanted = action.type === 'check';
+                const target = requireTarget(action);
+                const found = await this.element(target, timeout);
+                if ((await client.isElementSelected(found.elementId)) !== wanted) {
+                    await this.retrying(timeout, target, (id) => client.elementClick(id));
+                }
+                await expectWithin(Math.min(timeout, 2_000), async () => (await client.isElementSelected(found.elementId)) === wanted, `the element to be ${wanted ? 'checked' : 'unchecked'}`);
+                return {};
+            }
+            case 'fill': {
+                const value = render(action.value, this.ctx.template);
+                await this.retrying(timeout, requireTarget(action), async (id) => {
+                    await client.elementClear(id);
+                    if (value)
+                        await client.elementSendKeys(id, value);
+                });
+                return {};
+            }
+            case 'select_option': {
+                const value = render(action.value, this.ctx.template);
+                const found = await this.element(requireTarget(action), timeout);
+                const options = await client.findElementsFromElement(found.elementId, 'css selector', 'option');
+                const seen = [];
+                for (const option of options) {
+                    const id = elementIdOf(option);
+                    const [optionValue, text] = await Promise.all([client.getElementProperty(id, 'value'), client.getElementText(id)]);
+                    seen.push(text.trim());
+                    if (optionValue === value || text.trim() === value) {
+                        await client.elementClick(id);
+                        return {};
+                    }
+                }
+                throw new Error(`the list has no option "${value}" (options: ${seen.map((s) => `"${clip(s)}"`).join(', ') || 'none'})`);
+            }
+            case 'press': {
+                const keys = webdriverKeys(action.key ?? '');
+                if (action.target) {
+                    const found = await this.element(action.target, timeout);
+                    const chord = `${keys.modifiers.join('')}${keys.key}${keys.modifiers.length > 0 ? '' : ''}`;
+                    await client.elementSendKeys(found.elementId, chord);
+                }
+                else {
+                    await client.performActions(keyActions(keys));
+                    await client.releaseActions().catch(() => undefined);
+                }
+                return {};
+            }
+            case 'wait_for':
+                await this.element(requireTarget(action), timeout, true);
+                return {};
+            case 'wait':
+                await sleep(Math.min(action.ms ?? 0, 30_000));
+                return {};
+            case 'expect_visible': {
+                const target = requireTarget(action);
+                await expectWithin(timeout, () => this.visibleNow(target), `${describeDomTarget(target)} to be visible`);
+                return {};
+            }
+            case 'expect_hidden': {
+                const target = requireTarget(action);
+                await expectWithin(timeout, async () => !(await this.visibleNow(target)), `${describeDomTarget(target)} to be hidden`);
+                return {};
+            }
+            case 'expect_text': {
+                const target = requireTarget(action);
+                const expected = render(action.value, this.ctx.template);
+                let actual = '';
+                await expectWithin(timeout, async () => {
+                    const found = await this.element(target, 0, false);
+                    actual = (await client.getElementText(found.elementId)).trim();
+                    return matches(actual, expected, action.match);
+                }, () => `text to ${verb(action.match)} "${expected}", found "${clip(actual)}"`);
+                return {};
+            }
+            case 'expect_url': {
+                const expected = render(action.value, this.ctx.template);
+                let actual = '';
+                await expectWithin(timeout, async () => {
+                    actual = await client.getUrl();
+                    return matches(actual, expected, action.match);
+                }, () => `the URL to ${verb(action.match)} "${expected}", found "${clip(actual)}"`);
+                return {};
+            }
+            case 'expect_title': {
+                const expected = render(action.value, this.ctx.template);
+                let actual = '';
+                await expectWithin(timeout, async () => {
+                    actual = await client.getTitle();
+                    return matches(actual, expected, action.match);
+                }, () => `the title to ${verb(action.match)} "${expected}", found "${clip(actual)}"`);
+                return {};
+            }
+            case 'screenshot':
+                return { screenshot: await this.screenshot() };
+            default:
+                throw new Unsupported(`'${action.type}' is not a tauri action`);
+        }
+    }
+    async focusWindow(action) {
+        const client = this.requireClient();
+        const timeout = action.timeout_ms ?? this.ctx.timeouts.actionMs;
+        const wanted = action.title !== undefined ? render(action.title, this.ctx.template) : null;
+        let titles = [];
+        let count = 0;
+        const original = await client.getWindowHandle().catch(() => null);
+        await expectWithin(timeout, async () => {
+            const handles = await client.getWindowHandles();
+            count = handles.length;
+            if (wanted === null) {
+                const handle = handles[action.index ?? 0];
+                if (!handle)
+                    return false;
+                await client.switchToWindow(handle);
+                return true;
+            }
+            titles = [];
+            for (const handle of handles) {
+                await client.switchToWindow(handle);
+                const title = await client.getTitle().catch(() => '');
+                titles.push(title);
+                if (matches(title, wanted, action.match))
+                    return true;
+            }
+            if (original)
+                await client.switchToWindow(original).catch(() => undefined);
+            return false;
+        }, () => wanted === null
+            ? `window ${action.index} to be open, found ${count} window(s)`
+            : `a window whose title ${action.match === 'equals' ? 'equals' : 'contains'} "${wanted}", found ${titles.map((t) => `"${clip(t)}"`).join(', ') || 'none'}`);
+        this.refElements.clear();
+    }
+    async find(target) {
+        validateDomTarget(target);
+        const client = this.requireClient();
+        const byElement = new Map([...this.refElements].map(([ref, id]) => [id, ref]));
+        for (const candidate of domCandidates(target)) {
+            const found = await domFindAll(client, candidate, this.renderText, 20);
+            if (found.count === 0)
+                continue;
+            const nth = candidate.nth;
+            const ids = nth === undefined ? found.elementIds : found.elementIds.slice(nth, nth + 1);
+            const refs = ids.map((id) => byElement.get(id)).filter((ref) => ref !== undefined);
+            return { count: nth === undefined ? found.count : ids.length, refs };
+        }
+        return { count: 0, refs: [] };
+    }
+    async snapshot(options = {}) {
+        const client = this.requireClient();
+        const raw = (await client.executeScript(domScript('dom-snapshot'), [
+            {
+                ...(options.depth !== undefined ? { depth: options.depth } : {}),
+                ...(options.includeHidden !== undefined ? { includeHidden: options.includeHidden } : {}),
+            },
+        ]));
+        const built = buildDomSnapshot(raw, {
+            platform: 'tauri',
+            ...(options.maxChars !== undefined ? { maxChars: options.maxChars } : {}),
+            appId: this.ctx.job.app?.id || null,
+        });
+        this.refElements = built.elements;
+        return built.snapshot;
+    }
+    async screen() {
+        const client = this.requireClient();
+        const raw = (await client.executeScript(domScript('dom-snapshot'), [{ viewportOnly: true }]));
+        return domScreen(raw, this.ctx.job.app?.id || null);
+    }
+    async tapAt(x, y) {
+        if (!Number.isFinite(x) || !Number.isFinite(y))
+            throw new Error('coordinates must be numbers');
+        await this.requireClient().performActions([
+            {
+                type: 'pointer',
+                id: 'mouse',
+                parameters: { pointerType: 'mouse' },
+                actions: [
+                    { type: 'pointerMove', duration: 0, origin: 'viewport', x: Math.round(x), y: Math.round(y) },
+                    { type: 'pointerDown', button: 0 },
+                    { type: 'pointerUp', button: 0 },
+                ],
+            },
+        ]);
+    }
+    async back() {
+        throw new Unsupported("'back' is not available on tauri");
+    }
+    async home() {
+        throw new Unsupported("'home' is not available on tauri");
+    }
+    async screenshot() {
+        return Buffer.from(await this.requireClient().takeScreenshot(), 'base64');
+    }
+    source() {
+        return this.requireClient().getPageSource();
+    }
+    beginStep(_index) { }
+    debug(_index) {
+        return undefined;
+    }
+    /** Tauri jobs record no video (contracts §L). */
+    async stopRecording() {
+        return undefined;
+    }
+    async dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        await this.closeApp();
+        if (this.driverProcess)
+            killProcessTree(this.driverProcess.child.pid);
+        this.driverProcess = null;
+        await this.display?.stop().catch(() => undefined);
+        await disposeUnpacked(this.unpacked, this.ctx.log);
+        this.releaseBuild?.();
+    }
+    /** Ends the WebDriver session (tauri-driver closes the app) and kills a plugin app's process tree. */
+    async closeApp() {
+        const client = this.client;
+        this.client = null;
+        this.refElements.clear();
+        if (client)
+            await Promise.race([client.deleteSession().catch(() => undefined), sleep(10_000)]);
+        const app = this.app;
+        this.app = null;
+        if (app && !app.exited())
+            killProcessTree(app.child.pid);
+    }
+}
+function nodePlatform(os) {
+    if (os === 'macos')
+        return 'darwin';
+    if (os === 'windows')
+        return 'win32';
+    return os;
+}
+/** Availability for a host with the given settings (a device only when a backend is ready). */
+export function tauriAvailability(host, settings, lookup = {}) {
+    const backend = tauriBackend(settings, { ...lookup, platform: nodePlatform(host.os) });
+    if (backend.kind === 'unavailable')
+        return { ok: false, labels: [], devices: [], reasons: backend.reasons };
+    return { ok: true, labels: ['tauri'], devices: [hostDevice('tauri', { name: host.hostname })], reasons: [] };
+}
+export const tauriDriverFactory = {
+    platform: 'tauri',
+    async availability(host) {
+        return tauriAvailability(host, loadTauriSettings(process.env, homePaths(process.env)));
+    },
+    async create(ctx, _shared) {
+        const settings = loadTauriSettings(process.env, ctx.paths ?? homePaths(process.env));
+        const backend = tauriBackend(settings);
+        if (backend.kind === 'unavailable')
+            throw new Blocked(backend.reasons.join('; '));
+        return new TauriWebDriver(ctx, backend, { configuredNative: settings.nativeDriverPath !== null });
+    },
+};