verikun 0.4.1 → 0.7.0

package/dist/drivers/adb.js

@@ -233,6 +233,18 @@ class AdbDriver {
             throw new errors_1.CliError(`Failed to launch '${appId}': ${r.stderr.trim() || r.stdout.trim() || `exit code ${r.code}`}`, 3);
         }
     }
+    install(appPath) {
+        // `-r` reinstalls over an existing package keeping its data (the common
+        // update-the-build-under-test case). A large APK can legitimately take
+        // minutes to stream + install, so the timeout is far above the 30s default.
+        // adb reports failures both as a non-zero exit AND as a `Failure [REASON]`
+        // line on stdout with exit 0 (varies by adb version) — check both.
+        const r = (0, exec_1.runText)(ADB, this.withSerial(['install', '-r', appPath]), { timeout: 10 * 60 * 1000 });
+        const combined = `${r.stdout}\n${r.stderr}`;
+        if (r.code !== 0 || /^Failure\b/im.test(combined) || !/^Success\b/im.test(combined)) {
+            throw new errors_1.CliError(`Failed to install '${appPath}': ${combined.replace(/\s+/g, ' ').trim() || `exit code ${r.code}`}`, 3);
+        }
+    }
     stop(appId) {
         this.shell(['am', 'force-stop', appId]);
     }

package/dist/drivers/index.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimctlDriver = exports.AdbDriver = void 0;
+exports.IdbDriver = exports.AdbDriver = void 0;
 exports.getDriver = getDriver;
 const adb_1 = require("./adb");
-const simctl_1 = require("./simctl");
+const ios_1 = require("./ios");
 var adb_2 = require("./adb");
 Object.defineProperty(exports, "AdbDriver", { enumerable: true, get: function () { return adb_2.AdbDriver; } });
-var simctl_2 = require("./simctl");
-Object.defineProperty(exports, "SimctlDriver", { enumerable: true, get: function () { return simctl_2.SimctlDriver; } });
+var ios_2 = require("./ios");
+Object.defineProperty(exports, "IdbDriver", { enumerable: true, get: function () { return ios_2.IdbDriver; } });
 function getDriver(platform, device) {
-    return platform === 'ios' ? new simctl_1.SimctlDriver(device) : new adb_1.AdbDriver(device);
+    return platform === 'ios' ? new ios_1.IdbDriver(device) : new adb_1.AdbDriver(device);
 }

package/dist/drivers/ios.js

@@ -0,0 +1,358 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdbDriver = void 0;
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
+const errors_1 = require("../errors");
+const exec_1 = require("../exec");
+const ios_parse_1 = require("../ui/ios-parse");
+// iOS driver. `xcrun simctl` / `devicectl` cover device discovery and — on a
+// simulator — screenshots, app lifecycle, and logs (no extra install needed).
+// Everything interactive (UI hierarchy, tap, type, swipe, keys, screen size) and
+// all interaction on physical devices go through Facebook's `idb`, a CLI shelled
+// one-shot exactly like `adb` — so this driver keeps verikun's zero-runtime-dep,
+// process-per-command shape. Install: `brew install idb-companion` + `pip install
+// fb-idb` (see `vk doctor --ios`).
+//
+// Coordinates are in idb's point space: `idb ui describe-all` frames, `idb ui tap`,
+// and `idb describe` screen_dimensions all agree, so element.center taps land.
+// (simctl screenshots are pixels = points × scale — they are for viewing only and
+// never feed back into a tap.)
+const XCRUN = 'xcrun';
+const IDB = process.env.IDB || 'idb';
+const DEFAULT_LOG_LINES = 200;
+const DEFAULT_LOG_WINDOW = '5m';
+// Named keys -> USB-HID keyboard usage IDs, handed to `idb ui key <code>`. Numeric
+// codes are accepted directly. Names mirror the adb driver so cross-platform
+// batch/ai scripts share one vocabulary.
+const IOS_KEYCODES = {
+    enter: 40,
+    return: 40,
+    escape: 41,
+    esc: 41,
+    del: 42,
+    delete: 42,
+    backspace: 42,
+    tab: 43,
+    space: 44,
+    forward_del: 76,
+    move_home: 74,
+    move_end: 77,
+    page_up: 75,
+    page_down: 78,
+    right: 79,
+    dpad_right: 79,
+    left: 80,
+    dpad_left: 80,
+    down: 81,
+    dpad_down: 81,
+    up: 82,
+    dpad_up: 82,
+};
+// Named hardware buttons -> `idb ui button <NAME>` (the only accepted set).
+const IOS_BUTTONS = {
+    home: 'HOME',
+    lock: 'LOCK',
+    power: 'LOCK',
+    side_button: 'SIDE_BUTTON',
+    siri: 'SIRI',
+    apple_pay: 'APPLE_PAY',
+};
+function listPhysicalDevices() {
+    const r = (0, exec_1.runText)(XCRUN, ['devicectl', 'list', 'devices']);
+    if (r.code !== 0)
+        return [];
+    const lines = r.stdout.split('\n');
+    const headerIdx = lines.findIndex((l) => l.includes('Identifier'));
+    if (headerIdx < 0)
+        return [];
+    const header = lines[headerIdx];
+    const nameCol = header.indexOf('Name');
+    const hostCol = header.indexOf('Hostname');
+    const idCol = header.indexOf('Identifier');
+    const stateCol = header.indexOf('State');
+    const modelCol = header.indexOf('Model');
+    const devices = [];
+    for (const line of lines.slice(headerIdx + 2)) {
+        if (!line.trim() || line.startsWith('-'))
+            continue;
+        const identifier = line.slice(idCol, stateCol).trim();
+        const state = line.slice(stateCol, modelCol).trim();
+        const name = line.slice(nameCol, hostCol).trim();
+        const model = line.slice(modelCol).trim();
+        if (!identifier)
+            continue;
+        const productMatch = model.match(/\(([^)]+)\)$/);
+        devices.push({
+            serial: identifier,
+            state,
+            model: name,
+            product: productMatch?.[1],
+            platform: 'ios',
+            note: 'physical — via idb (Developer mode + idb_companion; logs limited)',
+        });
+    }
+    return devices;
+}
+class IdbDriver {
+    platform = 'ios';
+    requested;
+    cachedSerial;
+    cachedIsSim;
+    constructor(device) {
+        // 'booted' is a simctl-only alias idb can't address, so treat it as "auto-resolve".
+        this.requested = device && device !== 'booted' ? device : undefined;
+    }
+    /** All available simulators (booted or shutdown) via simctl. Tolerates odd output. */
+    simulators() {
+        const devices = [];
+        const { stdout } = (0, exec_1.runText)(XCRUN, ['simctl', 'list', 'devices', 'available', '--json']);
+        try {
+            const data = JSON.parse(stdout);
+            for (const [runtime, list] of Object.entries(data.devices)) {
+                for (const d of list) {
+                    devices.push({
+                        serial: d.udid,
+                        state: d.state.toLowerCase(),
+                        model: d.name,
+                        product: runtime.split('.').pop(),
+                        platform: 'ios',
+                    });
+                }
+            }
+        }
+        catch {
+            /* tolerate unexpected simctl output */
+        }
+        return devices;
+    }
+    listDevices() {
+        return [...this.simulators(), ...listPhysicalDevices()];
+    }
+    resolvedSerial() {
+        if (this.cachedSerial)
+            return this.cachedSerial;
+        const sims = this.simulators();
+        const simUdids = new Set(sims.map((d) => d.serial));
+        if (this.requested) {
+            this.cachedSerial = this.requested;
+            this.cachedIsSim = simUdids.has(this.requested);
+            return this.cachedSerial;
+        }
+        // No explicit device: a booted simulator is the first-class, unambiguously
+        // drivable target, so prefer it. Only weigh physical devices when no simulator
+        // is booted — and only genuinely "connected" ones (devicectl also lists paired-
+        // but-idle devices as "available (paired)", which must not count as active).
+        const bootedSims = sims.filter((d) => d.state === 'booted');
+        const candidates = bootedSims.length > 0 ? bootedSims : listPhysicalDevices().filter((d) => /connected/i.test(d.state));
+        if (candidates.length === 0) {
+            throw new errors_1.CliError('No booted iOS simulator or connected device. Boot one (Simulator.app / `xcrun simctl boot`), then `verikun devices`.', 3);
+        }
+        if (candidates.length > 1) {
+            const list = candidates.map((d) => '  ' + d.serial + (d.model ? ` (${d.model})` : '')).join('\n');
+            throw new errors_1.CliError(`Multiple iOS targets; pass --device <udid> (or set VERIKUN_DEVICE):\n${list}`, 2);
+        }
+        this.cachedSerial = candidates[0].serial;
+        this.cachedIsSim = simUdids.has(candidates[0].serial);
+        return this.cachedSerial;
+    }
+    udid() {
+        return this.resolvedSerial();
+    }
+    isSimulator() {
+        this.resolvedSerial();
+        return this.cachedIsSim === true;
+    }
+    /** Run an idb subcommand against the resolved target, returning stdout. */
+    idbText(args, opts) {
+        const r = (0, exec_1.runText)(IDB, [...args, '--udid', this.udid()], opts);
+        if (r.code !== 0) {
+            throw new errors_1.CliError(`idb ${args.join(' ')} failed: ${r.stderr.trim() || `exit code ${r.code}`}`, 3);
+        }
+        return r.stdout;
+    }
+    getElements(opts = {}) {
+        // `idb ui describe-all` prints the accessibility tree as JSON (array or NDJSON);
+        // parseIosHierarchy handles either.
+        return (0, ios_parse_1.parseIosHierarchy)(this.idbText(['ui', 'describe-all'], { timeout: 15000 }), opts);
+    }
+    screenshot() {
+        const tmp = (0, node_path_1.join)((0, node_os_1.tmpdir)(), `verikun-ios-${process.pid}.png`);
+        if (this.isSimulator()) {
+            const r = (0, exec_1.runText)(XCRUN, ['simctl', 'io', this.udid(), 'screenshot', tmp]);
+            if (r.code !== 0)
+                throw new errors_1.CliError(`simctl screenshot failed: ${r.stderr.trim()}`, 3);
+        }
+        else {
+            this.idbText(['screenshot', tmp]);
+        }
+        let buf;
+        try {
+            buf = (0, node_fs_1.readFileSync)(tmp);
+        }
+        catch (e) {
+            throw new errors_1.CliError(`Could not read iOS screenshot: ${e.message}`, 3);
+        }
+        finally {
+            try {
+                (0, node_fs_1.unlinkSync)(tmp);
+            }
+            catch {
+                /* best-effort cleanup */
+            }
+        }
+        if (buf.length < 8 || buf[0] !== 0x89 || buf[1] !== 0x50) {
+            throw new errors_1.CliError('iOS screenshot was not a PNG.', 3);
+        }
+        return buf;
+    }
+    screenSize() {
+        // Prefer idb's target description (points, same space as tap/swipe).
+        try {
+            const d = JSON.parse(this.idbText(['describe', '--json']));
+            const w = Number(d.screen_dimensions?.width);
+            const h = Number(d.screen_dimensions?.height);
+            if (w > 0 && h > 0)
+                return { width: w, height: h };
+        }
+        catch {
+            /* fall through to deriving from the hierarchy */
+        }
+        // Fallback: the extent of the on-screen hierarchy (the window/app root frame).
+        let width = 0;
+        let height = 0;
+        for (const el of (0, ios_parse_1.parseIosHierarchy)(this.idbText(['ui', 'describe-all']), { all: true })) {
+            width = Math.max(width, el.bounds.x2);
+            height = Math.max(height, el.bounds.y2);
+        }
+        if (width > 0 && height > 0)
+            return { width, height };
+        throw new errors_1.CliError('Could not determine iOS screen size via idb.', 3);
+    }
+    tap(x, y) {
+        this.idbText(['ui', 'tap', String(Math.round(x)), String(Math.round(y))]);
+    }
+    swipe(x1, y1, x2, y2, _durationMs) {
+        // idb controls swipe speed via `--delta` (px per step), not a ms duration, and
+        // the flag's availability varies by version — so we pass coordinates only for
+        // maximum compatibility. durationMs is not honored (a documented iOS gap).
+        this.idbText([
+            'ui',
+            'swipe',
+            String(Math.round(x1)),
+            String(Math.round(y1)),
+            String(Math.round(x2)),
+            String(Math.round(y2)),
+        ]);
+    }
+    inputText(text) {
+        if (!text)
+            return;
+        // Passed as a single argv (spawnSync, no host shell), so no device-shell escaping
+        // is needed — idb synthesizes the keystrokes itself.
+        this.idbText(['ui', 'text', text]);
+    }
+    pressKey(name) {
+        const key = name.toLowerCase();
+        const button = IOS_BUTTONS[key];
+        if (button) {
+            this.idbText(['ui', 'button', button]);
+            return;
+        }
+        const code = IOS_KEYCODES[key] ?? (/^\d+$/.test(name) ? Number(name) : undefined);
+        if (code === undefined) {
+            const hint = key === 'back' ? ' (iOS has no hardware Back — tap the on-screen back control instead)' : '';
+            throw new errors_1.CliError(`Unknown iOS key '${name}'${hint}. Known keys: ${Object.keys(IOS_KEYCODES).join(', ')}; ` +
+                `hardware buttons: ${Object.keys(IOS_BUTTONS).join(', ')}; or a numeric HID keycode.`, 2);
+        }
+        this.idbText(['ui', 'key', String(code)]);
+    }
+    launch(appId) {
+        if (this.isSimulator()) {
+            const r = (0, exec_1.runText)(XCRUN, ['simctl', 'launch', this.udid(), appId]);
+            if (r.code !== 0)
+                throw new errors_1.CliError(`simctl launch failed: ${r.stderr.trim()}`, 3);
+        }
+        else {
+            this.idbText(['launch', appId]);
+        }
+    }
+    install(appPath) {
+        // idb install handles both simulators and physical devices, and both .ipa
+        // archives and .app bundles locally. (The REMOTE install path accepts only
+        // single-file .ipa uploads in v1 — a .app is a directory, which the streamed
+        // upload can't carry; see server.ts.) Installs can take minutes.
+        this.idbText(['install', appPath], { timeout: 10 * 60 * 1000 });
+    }
+    stop(appId) {
+        // Best-effort force-stop. `terminate` reports a non-zero exit when the app simply
+        // wasn't running; that's a no-op success for us (parity with adb `am force-stop`,
+        // which never fails), so we don't surface it — otherwise `launch`'s default
+        // restart (stop-then-launch) would break whenever the app is already closed.
+        try {
+            if (this.isSimulator()) {
+                (0, exec_1.runText)(XCRUN, ['simctl', 'terminate', this.udid(), appId]);
+            }
+            else {
+                (0, exec_1.runText)(IDB, ['terminate', appId, '--udid', this.udid()]);
+            }
+        }
+        catch {
+            /* tool missing / target gone — nothing to stop */
+        }
+    }
+    clearApp(appId) {
+        // Honest degrade (no clean per-app data reset on iOS): don't silently uninstall.
+        throw new errors_1.CliError(`iOS app-data clearing is not supported (requested for '${appId}').\n` +
+            'iOS has no per-app data reset; the manual equivalent is uninstall + reinstall ' +
+            '(`xcrun simctl uninstall <udid> <bundleId>`), which removes the app too.', 3);
+    }
+    currentApp() {
+        // iOS exposes no reliable foreground-app query; degrade like adb's fallback.
+        return '(unknown)';
+    }
+    getLogs(opts = {}) {
+        if (!this.isSimulator()) {
+            throw new errors_1.CliError('iOS physical-device log capture is not supported (simulator logs work via `log show`).\n' +
+                'Use Console.app or `idb log` directly for a connected device.', 3);
+        }
+        // `log show` on the whole store is huge, so ALWAYS bound it: a session marker
+        // (--start) or a recent window (--last). Args go through spawnSync (no shell),
+        // so the marker/predicate need no escaping and can't inject.
+        const args = ['simctl', 'spawn', this.udid(), 'log', 'show', '--style', 'syslog'];
+        if (opts.since) {
+            args.push('--start', opts.since);
+        }
+        else {
+            args.push('--last', DEFAULT_LOG_WINDOW);
+        }
+        if (opts.appId) {
+            // Best-effort process scope: the simulator process name is usually the bundle's
+            // last component. A loose predicate is better than none for a crash trace.
+            const proc = opts.appId.split('.').pop() || opts.appId;
+            args.push('--predicate', `process CONTAINS "${proc}"`);
+        }
+        const out = (0, exec_1.runText)(XCRUN, args, { timeout: 20000 }).stdout;
+        if (opts.since)
+            return out; // the whole session window
+        // No explicit since → keep the last N lines, like adb's `logcat -t N`.
+        const n = opts.lines && opts.lines > 0 ? Math.floor(opts.lines) : DEFAULT_LOG_LINES;
+        const lines = out.split('\n');
+        return lines.slice(Math.max(0, lines.length - n)).join('\n');
+    }
+    deviceTime() {
+        // Simulator shares the host clock; sample it in `log show --start` format so the
+        // run's log window (run.ts) can anchor on it. Physical devices → '' (no marker),
+        // which disables windowing gracefully. Never throws (called at run start).
+        try {
+            if (!this.isSimulator())
+                return '';
+            return (0, exec_1.runText)(XCRUN, ['simctl', 'spawn', this.udid(), 'date', '+%Y-%m-%d %H:%M:%S']).stdout.trim();
+        }
+        catch {
+            return '';
+        }
+    }
+}
+exports.IdbDriver = IdbDriver;

package/dist/report.js

@@ -1,10 +1,14 @@
 "use strict";
-// Pure report rendering: a finished RunState in -> a JUnit XML / HTML string out.
+// Pure report rendering: a finished RunState in -> a JUnit XML / HTML string out,
+// and a finished SuiteRun in -> the suite index.json / index.html out.
 // No fs, no device, no side effects — so it is trivially testable and the run
-// recorder (run.ts) owns all the I/O. The data model lives in run.ts; we import
-// the types only.
+// recorder (run.ts) / suite runner (suite.ts) own all the I/O. The RunState data
+// model lives in run.ts; we import the types only.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toJUnitXml = toJUnitXml;
+exports.suiteTotals = suiteTotals;
+exports.toSuiteIndexJson = toSuiteIndexJson;
+exports.toSuiteHtml = toSuiteHtml;
 exports.toHtml = toHtml;
 // --- escaping -------------------------------------------------------------
 // XML 1.0 forbids most control chars even when escaped; drop them so a stray
@@ -180,6 +184,92 @@ function stepHtml(s) {
         parts.push(`<details><summary>Device logs</summary><pre>${htmlEsc(s.logs)}</pre></details>`);
     return `<li class="step ${s.status}">${parts.join('\n    ')}</li>`;
 }
+/** Tally a suite's tests into its totals (pure; used by suite.ts and tests). */
+function suiteTotals(tests) {
+    const round = (n) => Number(n.toFixed(4));
+    return {
+        tests: tests.length,
+        passed: tests.filter((t) => t.ok).length,
+        failed: tests.filter((t) => !t.ok).length,
+        steps: tests.reduce((a, t) => a + t.steps, 0),
+        costUsd: round(tests.reduce((a, t) => a + t.costUsd, 0)),
+        durationMs: tests.reduce((a, t) => a + t.durationMs, 0),
+    };
+}
+function toSuiteIndexJson(suite) {
+    return JSON.stringify(suite, null, 2) + '\n';
+}
+const SUITE_STYLE = `
+  table.tests { width:100%; border-collapse:collapse; background:#fff; border:1px solid var(--line); border-radius:8px; overflow:hidden; }
+  table.tests th, table.tests td { text-align:left; padding:10px 12px; border-top:1px solid var(--line); font-size:13px; }
+  table.tests th { background:#eaeef2; color:var(--muted); border-top:none; font-size:12px; letter-spacing:.03em; text-transform:uppercase; }
+  table.tests td.num { text-align:right; font-variant-numeric:tabular-nums; white-space:nowrap; }
+  table.tests a { color:inherit; }
+  .fail-reason { color:var(--fail); font-size:12px; margin-top:2px; }
+`;
+function suiteTestRow(t, linkBase) {
+    // A test that errored before its run started (id '') has no report to link.
+    const label = t.id
+        ? `<a href="${htmlEsc(`${linkBase}runs/${encodeURIComponent(t.id)}/report.html`)}">${htmlEsc(t.name)}</a>`
+        : htmlEsc(t.name);
+    const failure = t.failure ? `<div class="fail-reason">${htmlEsc(t.failure)}</div>` : '';
+    return `  <tr>
+    <td><span class="st ${t.ok ? 'passed' : 'failed'}">${t.ok ? 'PASS' : 'FAIL'}</span></td>
+    <td>${label}${failure}</td>
+    <td class="num">${t.passedSteps}/${t.steps}${t.failedSteps ? ` (${t.failedSteps} failed)` : ''}</td>
+    <td class="num">${t.modelRepairs || ''}</td>
+    <td class="num">$${t.costUsd.toFixed(4)}</td>
+    <td class="num">${fmtDuration(t.durationMs)}</td>
+  </tr>`;
+}
+/**
+ * The suite overview page. `linkBase` is the relative path from index.html to the
+ * directory holding `runs/<id>/report.html` — '../../' when the suite lives at
+ * .verikun/suites/<id>/ and runs at .verikun/runs/<id>/ (the default layout).
+ */
+function toSuiteHtml(suite, opts = {}) {
+    const linkBase = opts.linkBase ?? '../../';
+    const t = suite.totals;
+    const chips = [
+        `<span class="chip pass">${t.passed} passed</span>`,
+        t.failed ? `<span class="chip fail">${t.failed} failed</span>` : '',
+        `<span class="chip muted">${t.tests} tests &middot; ${t.steps} steps &middot; ${fmtDuration(t.durationMs)} &middot; $${t.costUsd.toFixed(4)}</span>`,
+    ]
+        .filter(Boolean)
+        .join('\n      ');
+    const metaBits = [
+        `<code>${htmlEsc(suite.id)}</code>`,
+        htmlEsc(suite.platform) + (suite.device ? ` · ${htmlEsc(suite.device)}` : ''),
+        `started ${htmlEsc(suite.startedAt)}`,
+        `finished ${htmlEsc(suite.finishedAt)}`,
+        `verikun ${htmlEsc(suite.verikun)}`,
+    ].filter(Boolean);
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>verikun suite — ${htmlEsc(suite.name)}</title>
+<style>${STYLE}${SUITE_STYLE}</style>
+</head>
+<body>
+<div class="wrap">
+  <h1>verikun test suite — ${htmlEsc(suite.name)}</h1>
+  <div class="meta">${metaBits.join(' &middot; ')}</div>
+  <div class="summary">
+      ${chips}
+  </div>
+  <table class="tests">
+    <thead><tr><th></th><th>Test</th><th>Steps</th><th>Repairs</th><th>Cost</th><th>Duration</th></tr></thead>
+    <tbody>
+${suite.tests.map((x) => suiteTestRow(x, linkBase)).join('\n')}
+    </tbody>
+  </table>
+</div>
+</body>
+</html>
+`;
+}
 function toHtml(run) {
     const c = counts(run);
     const chips = [

package/dist/rpc.js

@@ -0,0 +1,46 @@
+"use strict";
+// The remote-execution wire contract shared by `vk server` (src/server.ts) and the
+// remote backend (src/agent/remote.ts): request/response shapes plus the error codec
+// that carries a thrown error's SUBCLASS IDENTITY across the wire. The `vk ai` engine
+// decides heal-vs-terminal via `instanceof SelectorNotFoundError/AmbiguousSelectorError`
+// (agent/engine.ts), so a serialized error must rebuild into the same class — a plain
+// `{message}` would silently turn every remote selector miss into a terminal failure.
+//
+// Pure types + pure functions only: no http, no fetch, no fs — so both sides (and the
+// unit tests) can import it without dragging in transport code.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeError = describeError;
+exports.rebuildError = rebuildError;
+const errors_1 = require("./errors");
+// --- error codec ------------------------------------------------------------
+/** Serialize a thrown error for the wire, preserving what the engine needs to
+ *  tell a heal trigger from a terminal failure. */
+function describeError(e) {
+    if (e instanceof errors_1.AmbiguousSelectorError) {
+        return { kind: 'AmbiguousSelectorError', name: e.name, message: e.message, exitCode: e.exitCode, candidates: e.candidates };
+    }
+    if (e instanceof errors_1.SelectorNotFoundError) {
+        return { kind: 'SelectorNotFoundError', name: e.name, message: e.message, exitCode: e.exitCode };
+    }
+    if (e instanceof errors_1.CliError) {
+        return { kind: 'CliError', name: e.name, message: e.message, exitCode: e.exitCode };
+    }
+    return { kind: 'Error', name: e.name || 'Error', message: e.message, exitCode: 3 };
+}
+/** Rebuild the error a server serialized, restoring its class so `instanceof`
+ *  checks (and `candidates` / `exitCode`) behave as if it were thrown locally. */
+function rebuildError(d) {
+    switch (d.kind) {
+        case 'AmbiguousSelectorError':
+            return new errors_1.AmbiguousSelectorError(d.message, d.candidates ?? []);
+        case 'SelectorNotFoundError':
+            return new errors_1.SelectorNotFoundError(d.message);
+        case 'CliError':
+            return new errors_1.CliError(d.message, d.exitCode);
+        default: {
+            const e = new Error(d.message);
+            e.name = d.name || 'Error';
+            return e;
+        }
+    }
+}