@leera.io/qa-runner 1.0.0

package/dist/src/debug.js

@@ -0,0 +1,137 @@
+/** Per step, so one noisy page cannot push a whole case past the server's size limit. */
+const MAX_CONSOLE = 100;
+const MAX_PAGE_ERRORS = 50;
+const MAX_REQUESTS = 200;
+const MAX_TEXT = 1_000;
+/** Kept even when they succeed: these are the calls a failing step usually hinges on. */
+const API_RESOURCE_TYPES = new Set(['fetch', 'xhr', 'document', 'eventsource', 'websocket']);
+const SENSITIVE_PARAM = /token|secret|password|passwd|pwd|auth|session|signature|sig|key|code|credential/i;
+/**
+ * Collects what the browser reports while a script runs and files each entry
+ * under the step that was running when it happened.
+ *
+ * Only what a person debugging a failure needs is kept: console errors and
+ * warnings, uncaught page errors, and requests. Headers and bodies are never
+ * recorded, since they carry cookies and the credential the script signs in with.
+ */
+export class DebugCollector {
+    steps = new Map();
+    current = null;
+    startedAt;
+    redact;
+    constructor(startedAt, redact) {
+        this.startedAt = startedAt;
+        this.redact = redact;
+    }
+    attach(page) {
+        page.on('console', (message) => this.onConsole(message));
+        page.on('pageerror', (error) => this.push('page_errors', MAX_PAGE_ERRORS, { message: this.text(error.stack || error.message), at_secs: this.now() }));
+        page.on('requestfinished', (request) => void this.onFinished(request));
+        page.on('requestfailed', (request) => this.push('requests', MAX_REQUESTS, {
+            ...this.describe(request),
+            failure: this.text(request.failure()?.errorText ?? 'failed'),
+        }));
+    }
+    /** Starts filing entries under `index`; returns the step's start, in seconds since the case began. */
+    begin(index) {
+        this.current = index;
+        const offset = this.now();
+        this.entry(index).video_offset_secs = offset;
+        return offset;
+    }
+    /** The step's capture, or undefined when nothing but its start time was recorded. */
+    for(index) {
+        const debug = this.steps.get(index);
+        if (!debug)
+            return undefined;
+        const { video_offset_secs: _offset, ...captured } = debug;
+        return Object.keys(captured).length > 0 ? debug : undefined;
+    }
+    onConsole(message) {
+        const type = message.type();
+        if (type !== 'error' && type !== 'warning')
+            return;
+        const { url, lineNumber } = message.location();
+        this.push('console', MAX_CONSOLE, {
+            type,
+            text: this.text(message.text()),
+            ...(url ? { location: `${this.url(url)}:${lineNumber + 1}` } : {}),
+            at_secs: this.now(),
+        });
+    }
+    async onFinished(request) {
+        // Captured before the await: by the time the response resolves, the next step may have begun.
+        const index = this.current;
+        const base = this.describe(request);
+        const response = await request.response().catch(() => null);
+        const status = response?.status();
+        if (!API_RESOURCE_TYPES.has(request.resourceType()) && (status === undefined || status < 400))
+            return;
+        const { responseEnd } = request.timing();
+        this.push('requests', MAX_REQUESTS, {
+            ...base,
+            ...(status === undefined ? {} : { status }),
+            ...(responseEnd >= 0 ? { duration_ms: Math.round(responseEnd) } : {}),
+        }, index);
+    }
+    describe(request) {
+        return {
+            method: request.method(),
+            url: this.url(request.url()),
+            resource_type: request.resourceType(),
+            at_secs: this.now(),
+        };
+    }
+    push(kind, cap, entry, index = this.current) {
+        if (index === null)
+            return;
+        const debug = this.entry(index);
+        const list = (debug[kind] ??= []);
+        if (list.length < cap) {
+            list.push(entry);
+        }
+        else {
+            debug.dropped ??= {};
+            debug.dropped[kind] = (debug.dropped[kind] ?? 0) + 1;
+        }
+    }
+    entry(index) {
+        let debug = this.steps.get(index);
+        if (!debug) {
+            debug = {};
+            this.steps.set(index, debug);
+        }
+        return debug;
+    }
+    now() {
+        return Math.round((Date.now() - this.startedAt) / 100) / 10;
+    }
+    text(value) {
+        const redacted = this.redact(value);
+        return redacted.length > MAX_TEXT ? `${redacted.slice(0, MAX_TEXT - 3)}...` : redacted;
+    }
+    url(value) {
+        return this.text(maskUrl(value));
+    }
+}
+/** Hides the values of query parameters that commonly carry secrets, and any user info. */
+export function maskUrl(raw) {
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        return raw;
+    }
+    if (url.protocol === 'data:' || url.protocol === 'blob:')
+        return `${url.protocol}…`;
+    if (url.username || url.password) {
+        url.username = '';
+        url.password = '';
+    }
+    for (const name of [...url.searchParams.keys()]) {
+        if (SENSITIVE_PARAM.test(name))
+            url.searchParams.set(name, '***');
+    }
+    return url.toString();
+}

package/dist/src/devices/android/adb.js

@@ -0,0 +1,251 @@
+import { execFile } from 'node:child_process';
+import { existsSync, readdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/** SDK directories to try, in order: config, `ANDROID_HOME`, `ANDROID_SDK_ROOT`, the per-OS default. */
+export function sdkCandidates(lookup) {
+    const platform = lookup.platform ?? process.platform;
+    const home = lookup.home ?? homedir();
+    const out = [];
+    const add = (path, source) => {
+        const trimmed = path?.trim();
+        if (trimmed && !out.some((c) => c.path === trimmed))
+            out.push({ path: trimmed, source });
+    };
+    add(lookup.configured, 'config');
+    add(lookup.env.ANDROID_HOME, 'ANDROID_HOME');
+    add(lookup.env.ANDROID_SDK_ROOT, 'ANDROID_SDK_ROOT');
+    if (platform === 'darwin')
+        add(join(home, 'Library', 'Android', 'sdk'), 'default');
+    else if (platform === 'win32') {
+        const local = lookup.env.LOCALAPPDATA?.trim() || join(home, 'AppData', 'Local');
+        add(join(local, 'Android', 'Sdk'), 'default');
+    }
+    else
+        add(join(home, 'Android', 'Sdk'), 'default');
+    return out;
+}
+function exe(name, platform) {
+    return platform === 'win32' ? `${name}.exe` : name;
+}
+function script(name, platform) {
+    return platform === 'win32' ? `${name}.bat` : name;
+}
+/** Compares dotted version strings numerically (`36.0.0` > `35.0.1`). */
+export function compareDotted(a, b) {
+    const pa = a.split(/[.-]/).map((p) => Number.parseInt(p, 10) || 0);
+    const pb = b.split(/[.-]/).map((p) => Number.parseInt(p, 10) || 0);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i += 1) {
+        const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (d !== 0)
+            return d;
+    }
+    return 0;
+}
+/** Finds the SDK: the first candidate directory that has `platform-tools/adb`. */
+export function resolveAndroidSdk(lookup) {
+    const platform = lookup.platform ?? process.platform;
+    const exists = lookup.exists ?? existsSync;
+    for (const { path, source } of sdkCandidates(lookup)) {
+        const adb = join(path, 'platform-tools', exe('adb', platform));
+        if (!exists(adb))
+            continue;
+        const emulator = join(path, 'emulator', exe('emulator', platform));
+        const sdkmanager = join(path, 'cmdline-tools', 'latest', 'bin', script('sdkmanager', platform));
+        const avdmanager = join(path, 'cmdline-tools', 'latest', 'bin', script('avdmanager', platform));
+        let buildTools = null;
+        try {
+            const versions = (lookup.list ?? defaultList)(join(path, 'build-tools')).filter((v) => /^\d/.test(v));
+            versions.sort(compareDotted);
+            const newest = versions.at(-1);
+            if (newest)
+                buildTools = join(path, 'build-tools', newest);
+        }
+        catch {
+            buildTools = null;
+        }
+        return {
+            root: path,
+            source,
+            adb,
+            emulator: exists(emulator) ? emulator : null,
+            sdkmanager: exists(sdkmanager) ? sdkmanager : null,
+            avdmanager: exists(avdmanager) ? avdmanager : null,
+            buildTools,
+        };
+    }
+    return null;
+}
+/**
+ * Finds sdkmanager for `--install-sdk`. Unlike `resolveAndroidSdk` this accepts a directory that has
+ * only `cmdline-tools/latest` (no platform-tools yet): sdkmanager then installs platform-tools itself.
+ * The first candidate that has sdkmanager wins.
+ */
+export function resolveSdkManager(lookup) {
+    const platform = lookup.platform ?? process.platform;
+    const exists = lookup.exists ?? existsSync;
+    for (const { path, source } of sdkCandidates(lookup)) {
+        const bin = join(path, 'cmdline-tools', 'latest', 'bin');
+        const sdkmanager = join(bin, script('sdkmanager', platform));
+        if (!exists(sdkmanager))
+            continue;
+        const avdmanager = join(bin, script('avdmanager', platform));
+        return { root: path, source, sdkmanager, avdmanager: exists(avdmanager) ? avdmanager : null };
+    }
+    return null;
+}
+function defaultList(path) {
+    try {
+        return readdirSync(path);
+    }
+    catch {
+        return [];
+    }
+}
+export class ToolError extends Error {
+    stderr;
+    code;
+    constructor(message, stderr, code) {
+        super(message);
+        this.stderr = stderr;
+        this.code = code;
+    }
+}
+/** Runs a tool with a fixed argv (no shell) and collects its output. */
+export function runTool(file, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        execFile(file, args, {
+            timeout: options.timeoutMs ?? 30_000,
+            maxBuffer: options.maxBuffer ?? 32 * 1024 * 1024,
+            windowsHide: true,
+            encoding: 'utf8',
+            ...(options.env ? { env: options.env } : {}),
+        }, (error, stdout, stderr) => {
+            if (error) {
+                const detail = (stderr || stdout || error.message).trim().split('\n').slice(-3).join(' ');
+                const code = error.code ?? null;
+                reject(new ToolError(`${file.split(/[\\/]/).pop()} ${args.slice(0, 4).join(' ')} failed: ${detail}`, stderr, code));
+                return;
+            }
+            resolve({ stdout, stderr });
+        });
+    });
+}
+/** Parses `adb devices -l`. */
+export function parseAdbDevices(output) {
+    const devices = [];
+    for (const raw of output.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (!line || line.startsWith('List of devices') || line.startsWith('*') || line.startsWith('adb '))
+            continue;
+        // "<serial>\s+<state>[ key:value ...]"; the state "no permissions" contains a space.
+        const match = /^(\S+)\s+(no permissions(?: \([^)]*\))?|\S+)(.*)$/.exec(line);
+        if (!match)
+            continue;
+        const [, serial, rawState, rest] = match;
+        const fields = {};
+        for (const token of (rest ?? '').trim().split(/\s+/)) {
+            const at = token.indexOf(':');
+            if (at > 0)
+                fields[token.slice(0, at)] = token.slice(at + 1);
+        }
+        devices.push({ serial: serial, state: rawState.startsWith('no permissions') ? 'no permissions' : rawState, fields });
+    }
+    return devices;
+}
+/** Parses `adb shell getprop` (`[key]: [value]` lines; values may span lines). */
+export function parseGetprop(output) {
+    const props = {};
+    const re = /\[([^\]]+)\]:\s*\[([\s\S]*?)\]\s*(?=\n\[|$)/g;
+    for (const match of output.replace(/\r\n/g, '\n').matchAll(re)) {
+        props[match[1]] = match[2];
+    }
+    return props;
+}
+export function isEmulatorSerial(serial) {
+    return /^emulator-\d+$/.test(serial);
+}
+/** Parses the console port out of `emulator-5554`. */
+export function emulatorPort(serial) {
+    const match = /^emulator-(\d+)$/.exec(serial);
+    return match ? Number(match[1]) : null;
+}
+/** Parses `adb emu avd name` ("Pixel_8_API_36\nOK"). */
+export function parseEmuAvdName(output) {
+    const lines = output
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .filter((l) => l && l !== 'OK');
+    return lines[0] ?? null;
+}
+/** Parses `pidof <package>` (space-separated pids). */
+export function parsePidof(output) {
+    return output
+        .trim()
+        .split(/\s+/)
+        .map((p) => Number.parseInt(p, 10))
+        .filter((p) => Number.isInteger(p) && p > 0);
+}
+/** A package name as Android defines it; checked before it is passed to any adb argv. */
+export const PACKAGE_RE = /^[A-Za-z][A-Za-z0-9_]*(\.[A-Za-z0-9_]+)+$/;
+export const SERIAL_RE = /^[A-Za-z0-9._:-]+$/;
+export function assertPackage(pkg) {
+    if (!PACKAGE_RE.test(pkg) || pkg.length > 255)
+        throw new Error(`'${pkg}' is not a valid Android package name`);
+    return pkg;
+}
+function assertSerial(serial) {
+    if (!SERIAL_RE.test(serial))
+        throw new Error(`'${serial}' is not a valid adb serial`);
+    return serial;
+}
+/** Thin wrapper over adb with fixed argv. */
+export class Adb {
+    path;
+    constructor(path) {
+        this.path = path;
+    }
+    run(args, timeoutMs = 30_000) {
+        return runTool(this.path, args, { timeoutMs }).then((r) => r.stdout);
+    }
+    async devices() {
+        return parseAdbDevices(await this.run(['devices', '-l'], 15_000));
+    }
+    shell(serial, args, timeoutMs = 30_000) {
+        return this.run(['-s', assertSerial(serial), 'shell', ...args], timeoutMs);
+    }
+    async getprops(serial) {
+        return parseGetprop(await this.shell(serial, ['getprop'], 15_000));
+    }
+    async getprop(serial, key) {
+        if (!/^[A-Za-z0-9._-]+$/.test(key))
+            throw new Error(`invalid property '${key}'`);
+        return (await this.shell(serial, ['getprop', key], 10_000)).trim();
+    }
+    async avdName(serial) {
+        try {
+            return parseEmuAvdName(await this.run(['-s', assertSerial(serial), 'emu', 'avd', 'name'], 10_000));
+        }
+        catch {
+            return null;
+        }
+    }
+    async install(serial, apk, timeoutMs = 300_000) {
+        const out = await this.run(['-s', assertSerial(serial), 'install', '-r', '-t', '-g', apk], timeoutMs);
+        if (/Failure \[/.test(out))
+            throw new Error(`the app could not be installed: ${out.trim().split('\n').pop()}`);
+    }
+    async uninstall(serial, pkg) {
+        await this.run(['-s', assertSerial(serial), 'uninstall', assertPackage(pkg)], 60_000).catch(() => undefined);
+    }
+    async isInstalled(serial, pkg) {
+        const out = await this.shell(serial, ['pm', 'path', assertPackage(pkg)], 15_000).catch(() => '');
+        return out.includes('package:');
+    }
+    async pidof(serial, pkg) {
+        return parsePidof(await this.shell(serial, ['pidof', assertPackage(pkg)], 10_000).catch(() => ''));
+    }
+    async killEmulator(serial) {
+        await this.run(['-s', assertSerial(serial), 'emu', 'kill'], 15_000).catch(() => undefined);
+    }
+}

package/dist/src/devices/android/avd.js

@@ -0,0 +1,95 @@
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { runTool } from './adb.js';
+/** AVD names as avdmanager allows them; anything else in `-list-avds` output is a log line. */
+export const AVD_NAME_RE = /^[A-Za-z0-9._-]+$/;
+/** Parses `emulator -list-avds`, skipping the INFO/WARNING lines newer emulators print. */
+export function parseAvdList(output) {
+    const names = [];
+    for (const raw of output.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (!line || !AVD_NAME_RE.test(line))
+            continue;
+        if (/^(INFO|WARNING|ERROR|ULOG)\b/.test(line))
+            continue;
+        if (!names.includes(line))
+            names.push(line);
+    }
+    return names;
+}
+export async function listAvds(emulator) {
+    const { stdout } = await runTool(emulator, ['-list-avds'], { timeoutMs: 20_000 });
+    return parseAvdList(stdout);
+}
+/** `ANDROID_AVD_HOME`, else `ANDROID_USER_HOME/avd`, else `~/.android/avd`. */
+export function avdHome(env, home = homedir()) {
+    if (env.ANDROID_AVD_HOME?.trim())
+        return env.ANDROID_AVD_HOME.trim();
+    if (env.ANDROID_USER_HOME?.trim())
+        return join(env.ANDROID_USER_HOME.trim(), 'avd');
+    return join(home, '.android', 'avd');
+}
+/** Parses an AVD `config.ini` / `<name>.ini` (`key=value`). */
+export function parseIni(text) {
+    const out = {};
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (!line || line.startsWith('#') || line.startsWith(';'))
+            continue;
+        const at = line.indexOf('=');
+        if (at <= 0)
+            continue;
+        out[line.slice(0, at).trim()] = line.slice(at + 1).trim();
+    }
+    return out;
+}
+/** Android release for an API level (what `os_version` reports for a device that is not booted). */
+export function androidVersionForApi(api) {
+    if (api === null)
+        return null;
+    const table = {
+        21: '5.0', 22: '5.1', 23: '6.0', 24: '7.0', 25: '7.1', 26: '8.0', 27: '8.1', 28: '9', 29: '10', 30: '11',
+        31: '12', 32: '12L', 33: '13', 34: '14', 35: '15', 36: '16', 37: '17',
+    };
+    return table[api] ?? null;
+}
+export function avdInfoFromIni(name, config, pointer = {}) {
+    const target = config.target ?? pointer.target ?? '';
+    let api = null;
+    const fromTarget = /android-(\d+)/.exec(target);
+    if (fromTarget)
+        api = Number(fromTarget[1]);
+    else {
+        const fromImage = /android-(\d+)/.exec(config['image.sysdir.1'] ?? '');
+        if (fromImage)
+            api = Number(fromImage[1]);
+    }
+    return {
+        name,
+        displayName: config['avd.ini.displayname'] ?? null,
+        apiLevel: api,
+        abi: config['abi.type'] ?? null,
+    };
+}
+export function readAvdInfo(name, env) {
+    if (!AVD_NAME_RE.test(name))
+        return { name, displayName: null, apiLevel: null, abi: null };
+    const dir = avdHome(env);
+    let pointer = {};
+    let config = {};
+    try {
+        pointer = parseIni(readFileSync(join(dir, `${name}.ini`), 'utf8'));
+    }
+    catch {
+        pointer = {};
+    }
+    const avdPath = pointer.path || join(dir, `${name}.avd`);
+    try {
+        config = parseIni(readFileSync(join(avdPath, 'config.ini'), 'utf8'));
+    }
+    catch {
+        config = {};
+    }
+    return avdInfoFromIni(name, config, pointer);
+}

package/dist/src/devices/android/emulator.js

@@ -0,0 +1,153 @@
+import { spawn } from 'node:child_process';
+import { closeSync, mkdirSync, openSync } from 'node:fs';
+import { createServer } from 'node:net';
+import { dirname } from 'node:path';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { emulatorPort } from './adb.js';
+import { AVD_NAME_RE } from './avd.js';
+/** Console ports adb scans for emulators (even ports; adb uses port + 1). */
+export const EMULATOR_PORT_MIN = 5554;
+export const EMULATOR_PORT_MAX = 5682;
+/** The fixed argv that boots an AVD on a given console port. */
+export function emulatorArgv(name, port, headless) {
+    if (!AVD_NAME_RE.test(name))
+        throw new Error(`'${name}' is not a valid AVD name`);
+    if (!Number.isInteger(port) || port < EMULATOR_PORT_MIN || port > EMULATOR_PORT_MAX || port % 2 !== 0) {
+        throw new Error(`emulator port ${port} is outside ${EMULATOR_PORT_MIN}-${EMULATOR_PORT_MAX}`);
+    }
+    return [
+        '-avd',
+        name,
+        '-port',
+        String(port),
+        '-no-audio',
+        '-no-boot-anim',
+        '-gpu',
+        'swiftshader_indirect',
+        ...(headless ? ['-no-window'] : []),
+    ];
+}
+function portFree(port) {
+    return new Promise((resolve) => {
+        const server = createServer();
+        server.once('error', () => resolve(false));
+        server.listen({ port, host: '127.0.0.1', exclusive: true }, () => server.close(() => resolve(true)));
+    });
+}
+/** The lowest even console port whose pair is free and not used by a running emulator. */
+export async function pickEmulatorPort(inUse, isFree = portFree) {
+    const taken = new Set(inUse);
+    for (let port = EMULATOR_PORT_MIN; port <= EMULATOR_PORT_MAX; port += 2) {
+        if (taken.has(port))
+            continue;
+        if ((await isFree(port)) && (await isFree(port + 1)))
+            return port;
+    }
+    throw new Error('no free emulator port between 5554 and 5682');
+}
+/** Boots in progress, by AVD name, so two jobs never start the same AVD twice. */
+const booting = new Map();
+/** Emulators this process started (serial → adb), so an ephemeral runner can shut them down when it exits. */
+const bootedHere = new Map();
+/** Serials of the emulators this process booted and has not shut down. */
+export function emulatorsBootedHere() {
+    return [...bootedHere.keys()];
+}
+/**
+ * Shuts down every emulator this process booted (`ci` owns them; a long-running `start`
+ * keeps emulators booted between jobs and does not call this). Returns the serials stopped.
+ */
+export async function shutdownEmulatorsBootedHere(timeoutMs = 60_000) {
+    const stopped = [];
+    for (const [serial, adb] of [...bootedHere]) {
+        await shutdownEmulator(adb, serial, timeoutMs).catch(() => undefined);
+        stopped.push(serial);
+    }
+    return stopped;
+}
+/** Finds a running emulator for the AVD, or null. */
+export async function findRunningAvd(adb, name) {
+    for (const device of await adb.devices()) {
+        if (emulatorPort(device.serial) === null)
+            continue;
+        if ((await adb.avdName(device.serial)) === name)
+            return device.serial;
+    }
+    return null;
+}
+/**
+ * Boots an AVD (or returns the serial it already runs as) and waits until Android reports
+ * `sys.boot_completed=1`. The emulator is detached: it stays booted between jobs.
+ */
+export function bootAvd(emulator, adb, name, options) {
+    const pending = booting.get(name);
+    if (pending)
+        return pending;
+    const promise = (async () => {
+        const running = await findRunningAvd(adb, name);
+        if (running) {
+            await waitForBoot(adb, running, options.timeoutMs ?? 300_000);
+            return running;
+        }
+        const ports = (await adb.devices()).map((d) => emulatorPort(d.serial)).filter((p) => p !== null);
+        const port = await pickEmulatorPort(ports);
+        const argv = emulatorArgv(name, port, options.headless);
+        let out = 'ignore';
+        if (options.logFile) {
+            mkdirSync(dirname(options.logFile), { recursive: true });
+            out = openSync(options.logFile, 'a');
+        }
+        const child = spawn(emulator, argv, {
+            detached: true,
+            stdio: ['ignore', out, out],
+            windowsHide: true,
+            ...(options.env ? { env: options.env } : {}),
+        });
+        if (typeof out === 'number')
+            closeSync(out);
+        let exited = null;
+        child.once('exit', (code, signal) => {
+            exited = `the emulator exited (${signal ?? `code ${code}`})${options.logFile ? `; see ${options.logFile}` : ''}`;
+        });
+        child.once('error', (error) => {
+            exited = `the emulator could not start: ${error.message}`;
+        });
+        child.unref();
+        const serial = `emulator-${port}`;
+        bootedHere.set(serial, adb);
+        await waitForBoot(adb, serial, options.timeoutMs ?? 300_000, () => exited);
+        return serial;
+    })().finally(() => booting.delete(name));
+    booting.set(name, promise);
+    return promise;
+}
+/** Waits for adb to see the device and for `sys.boot_completed` to become 1. */
+export async function waitForBoot(adb, serial, timeoutMs, failed = () => null) {
+    const deadline = Date.now() + timeoutMs;
+    for (;;) {
+        const failure = failed();
+        if (failure)
+            throw new Error(failure);
+        const device = (await adb.devices().catch(() => [])).find((d) => d.serial === serial);
+        if (device?.state === 'device') {
+            const completed = await adb.getprop(serial, 'sys.boot_completed').catch(() => '');
+            if (completed === '1')
+                return;
+        }
+        if (Date.now() > deadline) {
+            throw new Error(`${serial} did not finish booting within ${Math.round(timeoutMs / 1000)} s`);
+        }
+        await sleep(2_000);
+    }
+}
+export async function shutdownEmulator(adb, serial, timeoutMs = 60_000) {
+    bootedHere.delete(serial);
+    await adb.killEmulator(serial);
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const still = (await adb.devices().catch(() => [])).some((d) => d.serial === serial);
+        if (!still)
+            return;
+        await sleep(1_000);
+    }
+}