@shipvo/cli 0.1.4 → 0.1.6

package/dist/eas.d.ts

@@ -0,0 +1,29 @@
+export declare const ANDROID_IMAGE = "latest";
+export declare const IOS_IMAGE = "macos-tahoe-26.5-xcode-26.6";
+export declare const NODE_VERSION = "22";
+export declare const JDK_VERSION = "21";
+export interface CapacitorProject {
+    configFile: string;
+    android: boolean;
+    ios: boolean;
+}
+/** Look for a Capacitor project at `root`. Returns undefined when it is not one. */
+export declare function detectCapacitor(root: string): CapacitorProject | undefined;
+export interface PlannedFile {
+    path: string;
+    content: string;
+    action: "create" | "update";
+}
+/** Work out which files need writing. Existing build YAMLs and schemes are never overwritten. */
+export declare function planEasSetup(root: string, p: CapacitorProject): PlannedFile[];
+/** Create the `ios/App.xcodeproj -> App/App.xcodeproj` link the EAS CLI scheme check needs. Returns true if it made one. */
+export declare function ensureSchemeShim(root: string): boolean;
+export declare const ONE_TIME_STEPS: readonly [readonly ["eas-cli", "init"], readonly ["eas-cli", "build:version:set", "-p", "ios"]];
+export declare const IOS_UNPROVEN = "Note: the iOS signing steps in .eas/build/ios.yml are unproven. The step names were not checked against Expo's custom build functions (https://docs.expo.dev/custom-builds/schema/), so your first iOS build is the check.";
+export type Runner = (cmd: string, args: string[], cwd: string) => number;
+export interface EasOptions {
+    cwd?: string;
+    log?: (s: string) => void;
+    runner?: Runner;
+}
+export declare function easCmd(args: string[], o?: EasOptions): Promise<number>;

package/dist/eas.js

@@ -0,0 +1,258 @@
+// `shipvo eas setup` and `shipvo eas build`: make a Capacitor repo ready for `eas build` and `eas submit`
+// with the customer's own Expo account. Shipvo writes files; it never holds Expo credentials.
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, symlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { spawnSync } from "node:child_process";
+export const ANDROID_IMAGE = "latest";
+export const IOS_IMAGE = "macos-tahoe-26.5-xcode-26.6";
+export const NODE_VERSION = "22";
+export const JDK_VERSION = "21";
+const SCHEME_PATH = "ios/App/App.xcodeproj/xcshareddata/xcschemes/App.xcscheme";
+const SHIM = "ios/App.xcodeproj";
+const SHIM_TARGET = "App/App.xcodeproj";
+/** Look for a Capacitor project at `root`. Returns undefined when it is not one. */
+export function detectCapacitor(root) {
+    const configFile = readdirSync(root).find((f) => /^capacitor\.config\.(ts|js|json|mjs|cjs)$/.test(f));
+    const android = existsSync(join(root, "android"));
+    const ios = existsSync(join(root, "ios/App/App.xcodeproj"));
+    if (!configFile || (!android && !ios))
+        return undefined;
+    return { configFile, android, ios };
+}
+const androidYaml = `# Written by \`shipvo eas setup\`. Safe to edit; setup will not overwrite this file.
+# Docs: https://docs.expo.dev/custom-builds/get-started/
+build:
+  name: Capacitor Android release
+  steps:
+    - eas/checkout
+    - eas/install_node_modules
+    - run:
+        name: Install JDK ${JDK_VERSION}
+        command: |
+          source "$HOME/.sdkman/bin/sdkman-init.sh"
+          sdk install java ${JDK_VERSION}-tem < /dev/null
+          set-env JAVA_HOME "$(sdk home java ${JDK_VERSION}-tem)"
+    - run:
+        name: Build the web app
+        command: npm run build
+    - run:
+        name: Sync Capacitor
+        command: npx cap sync android
+    - eas/inject_android_credentials
+    - eas/run_gradle:
+        inputs:
+          command: :app:bundleRelease
+    - eas/find_and_upload_build_artifacts
+`;
+const iosYaml = `# Written by \`shipvo eas setup\`. Safe to edit; setup will not overwrite this file.
+# Docs: https://docs.expo.dev/custom-builds/get-started/
+# Before the first build, run \`shipvo eas build\`: it creates the ios/App.xcodeproj link that the EAS CLI scheme check needs on your machine before upload.
+build:
+  name: Capacitor iOS release
+  steps:
+    - eas/checkout
+    - eas/install_node_modules
+    - run:
+        name: Build the web app
+        command: npm run build
+    - run:
+        name: Sync Capacitor
+        command: npx cap sync ios
+    - run:
+        name: Install CocoaPods dependencies
+        command: cd ios/App && pod install
+    - eas/resolve_apple_team_id_from_credentials:
+        id: resolve_apple_team_id
+    - eas/prebuild_credentials_ios:
+        inputs:
+          project_dir: ios
+    - eas/configure_ios_credentials
+    - run:
+        name: Write ExportOptions.plist
+        # Nothing else creates this file. The team id comes from the EAS credentials step above;
+        # the profile name is read from the Xcode project that eas/configure_ios_credentials updated.
+        command: |
+          BUNDLE_ID="$(xcodebuild -project ios/App/App.xcodeproj -scheme App -configuration Release -showBuildSettings | awk -F' = ' '/ PRODUCT_BUNDLE_IDENTIFIER /{print $2; exit}')"
+          PROFILE="$(xcodebuild -project ios/App/App.xcodeproj -scheme App -configuration Release -showBuildSettings | awk -F' = ' '/ PROVISIONING_PROFILE_SPECIFIER /{print $2; exit}')"
+          cat > ios/App/ExportOptions.plist <<PLIST
+          <?xml version="1.0" encoding="UTF-8"?>
+          <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+          <plist version="1.0">
+          <dict>
+            <key>method</key><string>app-store</string>
+            <key>teamID</key><string>\${{ steps.resolve_apple_team_id.outputs.apple_team_id }}</string>
+            <key>signingStyle</key><string>manual</string>
+            <key>provisioningProfiles</key>
+            <dict><key>$BUNDLE_ID</key><string>$PROFILE</string></dict>
+          </dict>
+          </plist>
+          PLIST
+    - run:
+        name: Archive with distribution signing
+        command: |
+          xcodebuild archive \\
+            -workspace ios/App/App.xcworkspace \\
+            -scheme App \\
+            -configuration Release \\
+            -archivePath build/App.xcarchive \\
+            DEVELOPMENT_TEAM="\${{ steps.resolve_apple_team_id.outputs.apple_team_id }}" \\
+            CODE_SIGN_STYLE=Manual
+          xcodebuild -exportArchive \\
+            -archivePath build/App.xcarchive \\
+            -exportPath build/export \\
+            -exportOptionsPlist ios/App/ExportOptions.plist
+    - eas/find_and_upload_build_artifacts
+`;
+const scheme = `<?xml version="1.0" encoding="UTF-8"?>
+<Scheme LastUpgradeVersion="1600" version="1.7">
+  <BuildAction parallelizeBuildables="YES" buildImplicitDependencies="YES">
+    <BuildActionEntries>
+      <BuildActionEntry buildForTesting="YES" buildForRunning="YES" buildForProfiling="YES" buildForArchiving="YES" buildForAnalyzing="YES">
+        <BuildableReference BuildableIdentifier="primary" BlueprintName="App" BuildableName="App.app" BlueprintIdentifier="504EC3011FED79650016851F" ReferencedContainer="container:App.xcodeproj"/>
+      </BuildActionEntry>
+    </BuildActionEntries>
+  </BuildAction>
+  <LaunchAction buildConfiguration="Debug" selectedDebuggerIdentifier="Xcode.DebuggerFoundation.Debugger.LLDB" selectedLauncherIdentifier="Xcode.DebuggerFoundation.Launcher.LLDB" launchStyle="0" useCustomWorkingDirectory="NO" ignoresPersistentStateOnLaunch="NO" debugDocumentVersioning="YES" debugServiceExtension="internal" allowLocationSimulation="YES"/>
+  <ArchiveAction buildConfiguration="Release" revealArchiveInOrganizer="YES"/>
+</Scheme>
+`;
+function readJson(path) {
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (e) {
+        if (e.code === "ENOENT")
+            return {};
+        throw new Error(`${path} is not valid JSON. Fix it and run the command again.`);
+    }
+}
+/** Merge our profiles into an existing eas.json without touching the customer's own settings. */
+function easJson(root, p) {
+    const j = readJson(join(root, "eas.json"));
+    for (const k of ["cli", "build", "submit"]) {
+        if (j[k] !== undefined && (j[k] === null || typeof j[k] !== "object" || Array.isArray(j[k]))) {
+            throw new Error(`${join(root, "eas.json")} is not valid: "${k}" must be an object. Fix it and run the command again.`);
+        }
+    }
+    j.cli = { appVersionSource: "remote", ...(j.cli ?? {}) };
+    j.build ??= {};
+    if (p.android)
+        j.build["shipvo-android"] ??= { android: { image: ANDROID_IMAGE, buildType: "app-bundle", config: "android.yml" }, distribution: "store" };
+    if (p.ios)
+        j.build["shipvo-ios"] ??= { ios: { image: IOS_IMAGE, node: NODE_VERSION, config: "ios.yml" }, distribution: "store", autoIncrement: true };
+    j.submit ??= {};
+    if (p.android)
+        j.submit["shipvo-android"] ??= { android: {} };
+    if (p.ios)
+        j.submit["shipvo-ios"] ??= { ios: {} };
+    return JSON.stringify(j, null, 2) + "\n";
+}
+function gitignore(root) {
+    const path = join(root, ".gitignore");
+    const cur = existsSync(path) ? readFileSync(path, "utf8") : "";
+    if (cur.split(/\r?\n/).some((l) => l.trim() === SHIM))
+        return undefined;
+    const sep = cur === "" || cur.endsWith("\n") ? "" : "\n";
+    return `${cur}${sep}# Created by \`shipvo eas build\` for EAS; never commit\n${SHIM}\n`;
+}
+/** Work out which files need writing. Existing build YAMLs and schemes are never overwritten. */
+export function planEasSetup(root, p) {
+    const out = [];
+    const add = (path, content, overwrite) => {
+        const exists = existsSync(join(root, path));
+        if (exists && !overwrite)
+            return;
+        if (exists && readFileSync(join(root, path), "utf8") === content)
+            return;
+        out.push({ path, content, action: exists ? "update" : "create" });
+    };
+    add("eas.json", easJson(root, p), true);
+    if (p.android)
+        add(".eas/build/android.yml", androidYaml, false);
+    if (p.ios) {
+        add(".eas/build/ios.yml", iosYaml, false);
+        add(SCHEME_PATH, scheme, false);
+    }
+    const gi = p.ios ? gitignore(root) : undefined;
+    if (gi !== undefined)
+        out.push({ path: ".gitignore", content: gi, action: existsSync(join(root, ".gitignore")) ? "update" : "create" });
+    return out;
+}
+/** Create the `ios/App.xcodeproj -> App/App.xcodeproj` link the EAS CLI scheme check needs. Returns true if it made one. */
+export function ensureSchemeShim(root) {
+    const link = join(root, SHIM);
+    try {
+        lstatSync(link);
+        return false;
+    }
+    catch { /* missing: create it */ }
+    try {
+        symlinkSync(SHIM_TARGET, link, "dir");
+    }
+    catch (e) {
+        throw new Error(`Could not create the link ${SHIM} -> ${SHIM_TARGET} (${e.message}). Create it yourself (on Windows, run as administrator or turn on Developer Mode), then run the command again.`);
+    }
+    return true;
+}
+export const ONE_TIME_STEPS = [
+    ["eas-cli", "init"],
+    ["eas-cli", "build:version:set", "-p", "ios"],
+];
+export const IOS_UNPROVEN = "Note: the iOS signing steps in .eas/build/ios.yml are unproven. The step names were not checked against Expo's custom build functions (https://docs.expo.dev/custom-builds/schema/), so your first iOS build is the check.";
+const defaultRunner = (cmd, args, cwd) => spawnSync(cmd, args, { cwd, stdio: "inherit" }).status ?? 1;
+export async function easCmd(args, o = {}) {
+    const cwd = o.cwd ?? process.cwd();
+    const log = o.log ?? ((s) => console.log(s));
+    const runner = o.runner ?? defaultRunner;
+    const [sub, ...rest] = args;
+    if (sub !== "setup" && sub !== "build") {
+        throw new Error("Usage: shipvo eas setup [--dry-run] [--run] | shipvo eas build [eas build args]");
+    }
+    const project = detectCapacitor(cwd);
+    if (!project)
+        throw new Error("This is not a Capacitor project. Run this in a folder with capacitor.config.* and an android/ or ios/App/App.xcodeproj folder.");
+    if (sub === "build") {
+        if (project.ios && ensureSchemeShim(cwd))
+            log(`Linked ${SHIM} -> ${SHIM_TARGET} (git-ignored).`);
+        return runner("npx", ["eas-cli", "build", ...rest], cwd);
+    }
+    const known = ["--dry-run", "--run"];
+    const bad = rest.filter((a) => !known.includes(a));
+    if (bad.length)
+        throw new Error(`Unknown option for shipvo eas setup: ${bad.join(" ")}. Use --dry-run or --run.`);
+    const dry = rest.includes("--dry-run");
+    const runSteps = rest.includes("--run") && !dry;
+    const plan = planEasSetup(cwd, project);
+    for (const f of plan) {
+        log(`${dry ? "Would " + f.action : f.action === "create" ? "Created" : "Updated"} ${f.path}`);
+        if (dry)
+            log(f.content.replace(/^/gm, "  "));
+        else {
+            mkdirSync(dirname(join(cwd, f.path)), { recursive: true });
+            writeFileSync(join(cwd, f.path), f.content);
+        }
+    }
+    if (!plan.length)
+        log("Nothing to change: this repo is already set up for EAS.");
+    if (project.ios)
+        log(IOS_UNPROVEN);
+    if (dry)
+        return 0;
+    log("\nRemaining one-time steps:");
+    for (const s of ONE_TIME_STEPS)
+        log(`  npx ${s.join(" ")}`);
+    if (project.ios)
+        log("Before an iOS build, build with `shipvo eas build -p ios --profile shipvo-ios`: it creates the git-ignored ios/App.xcodeproj link first.");
+    if (runSteps) {
+        for (const s of ONE_TIME_STEPS) {
+            if (s[1] === "build:version:set" && !project.ios)
+                continue;
+            const code = runner("npx", [...s], cwd);
+            if (code !== 0) {
+                log(`\`npx ${s.join(" ")}\` failed (exit ${code}). Fix that and run it again.`);
+                return code;
+            }
+        }
+    }
+    return 0;
+}

package/dist/ensure-playwright.d.ts

@@ -0,0 +1,25 @@
+export type PackageManager = "pnpm" | "yarn" | "bun" | "npm";
+export interface EnsurePlaywrightDeps {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    /** Does this path exist? Used to find the lockfile. */
+    exists: (path: string) => boolean;
+    /** Runs a command in `cwd`. Throws if it fails. */
+    run: (cmd: string, args: string[], cwd: string) => void;
+    log: (line: string) => void;
+    /** True when `playwright` resolves from the app. Defaults to the same lookup order as `doctor`. */
+    resolves?: (cwd: string) => boolean;
+    /** Keep stdout clean (for `--json`): the notice and the installer's output go to stderr. */
+    quiet?: boolean;
+}
+/** stdio for the installer: stderr for both streams when quiet, so stdout stays clean. */
+export declare function installerStdio(quiet: boolean): "inherit" | ["ignore", 2, 2];
+export declare function detectPackageManager(cwd: string, exists: (path: string) => boolean): PackageManager;
+export declare function installCommand(pm: PackageManager): {
+    cmd: string;
+    args: string[];
+};
+/** Installs `playwright` as a dev dependency with the app's package manager when it is missing. */
+export declare function ensurePlaywright(deps: Partial<EnsurePlaywrightDeps> & {
+    cwd: string;
+}): void;

package/dist/ensure-playwright.js

@@ -0,0 +1,69 @@
+import { execFileSync, execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { join } from "node:path";
+/** stdio for the installer: stderr for both streams when quiet, so stdout stays clean. */
+export function installerStdio(quiet) {
+    return quiet ? ["ignore", 2, 2] : "inherit";
+}
+const LOCKFILES = [
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["bun.lock", "bun"],
+    ["bun.lockb", "bun"],
+];
+export function detectPackageManager(cwd, exists) {
+    for (const [file, pm] of LOCKFILES)
+        if (exists(join(cwd, file)))
+            return pm;
+    return "npm";
+}
+export function installCommand(pm) {
+    switch (pm) {
+        case "pnpm": return { cmd: "pnpm", args: ["add", "-D", "playwright"] };
+        case "yarn": return { cmd: "yarn", args: ["add", "-D", "playwright"] };
+        case "bun": return { cmd: "bun", args: ["add", "-d", "playwright"] };
+        default: return { cmd: "npm", args: ["install", "--save-dev", "playwright"] };
+    }
+}
+/** Same lookup order as doctor's playwrightChromiumPath: the app, this package, @shipvo/sim, then the global npm root. */
+function playwrightResolves(cwd) {
+    const tries = [
+        () => createRequire(join(cwd, "package.json")).resolve("playwright"),
+        () => createRequire(import.meta.url).resolve("playwright"),
+        () => createRequire(createRequire(import.meta.url).resolve("@shipvo/sim/package.json")).resolve("playwright"),
+        () => createRequire(import.meta.url).resolve(join(execSync("npm root -g", { stdio: ["ignore", "pipe", "ignore"] }).toString().trim(), "playwright")),
+    ];
+    for (const t of tries) {
+        try {
+            t();
+            return true;
+        }
+        catch { }
+    }
+    return false;
+}
+/** Installs `playwright` as a dev dependency with the app's package manager when it is missing. */
+export function ensurePlaywright(deps) {
+    const { cwd } = deps;
+    const env = deps.env ?? process.env;
+    const exists = deps.exists ?? existsSync;
+    const quiet = deps.quiet ?? false;
+    const run = deps.run ?? ((cmd, args, dir) => { execFileSync(cmd, args, { cwd: dir, stdio: installerStdio(quiet) }); });
+    const log = deps.log ?? ((line) => (quiet ? console.error(line) : console.log(line)));
+    if ((deps.resolves ?? playwrightResolves)(cwd))
+        return;
+    const { cmd, args } = installCommand(detectPackageManager(cwd, exists));
+    const line = [cmd, ...args].join(" ");
+    if (env.SHIPVO_NO_AUTO_INSTALL === "1") {
+        throw new Error(`playwright is not installed and SHIPVO_NO_AUTO_INSTALL=1 is set. Run \`${line}\` in ${cwd}.`);
+    }
+    log(`playwright is not installed. Running: ${line}`);
+    try {
+        run(cmd, args, cwd);
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new Error(`\`${line}\` failed: ${msg}`);
+    }
+}

package/dist/explore-issues.d.ts

@@ -0,0 +1,12 @@
+import { type Finding, type Skin } from "./explore.js";
+/** A short name for the screen: its first heading, else its first named line, else "unnamed screen". */
+export declare function screenName(tree: string): string;
+export declare function findingToIssue(f: Finding, skin: Skin): {
+    title: string;
+    body: string;
+};
+/** Writes `<n>-<kind>.md` per distinct finding. Returns the files and the `gh issue create` lines. */
+export declare function writeIssues(findings: Finding[], skin: Skin, dir: string): {
+    files: string[];
+    commands: string[];
+};

package/dist/explore-issues.js

@@ -0,0 +1,50 @@
+// `shipvo explore --issues-dir`: one ready-to-file Markdown issue per finding. Pure, so tests need no simulator.
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { describeStep, PARITY_LIMITS, signature } from "./explore.js";
+/** A short name for the screen: its first heading, else its first named line, else "unnamed screen". */
+export function screenName(tree) {
+    const h = /^\s*- heading "((?:[^"\\]|\\.)*)"/m.exec(tree);
+    if (h) {
+        try {
+            return JSON.parse(`"${h[1]}"`).trim() || "unnamed screen";
+        }
+        catch {
+            return h[1];
+        }
+    }
+    const any = /^\s*- [\w-]+ "((?:[^"\\]|\\.)*)"/m.exec(tree);
+    return any ? any[1] : "unnamed screen";
+}
+export function findingToIssue(f, skin) {
+    const title = `explore: ${f.kind} on ${screenName(f.screen)}`;
+    const body = [
+        f.message, "",
+        "Steps to reproduce:", "",
+        ...f.steps.map((s, i) => `${i + 1}. ${describeStep(s)}`), "",
+        `Platform skin: ${skin}`, "",
+        "Simulator limits:", "",
+        ...PARITY_LIMITS.map((p) => `- ${p}`), "",
+    ].join("\n");
+    return { title, body };
+}
+const quote = (s) => `'${s.replace(/'/g, `'\\''`)}'`;
+/** Writes `<n>-<kind>.md` per distinct finding. Returns the files and the `gh issue create` lines. */
+export function writeIssues(findings, skin, dir) {
+    const seen = new Set();
+    const files = [];
+    const commands = [];
+    const unique = findings.filter((f) => { const k = `${f.kind}|${f.message}|${signature(f.screen)}`; if (seen.has(k))
+        return false; seen.add(k); return true; });
+    if (!unique.length)
+        return { files, commands };
+    mkdirSync(dir, { recursive: true });
+    unique.forEach((f, i) => {
+        const { title, body } = findingToIssue(f, skin);
+        const file = join(dir, `${i + 1}-${f.kind}.md`);
+        writeFileSync(file, `${title}\n\n${body}`);
+        files.push(file);
+        commands.push(`gh issue create --title ${quote(title)} --body-file ${quote(file)}`);
+    });
+    return { files, commands };
+}

package/dist/explore.d.ts

@@ -0,0 +1,160 @@
+export type Step = {
+    action: "open";
+} | {
+    action: "open_url";
+    url: string;
+} | {
+    action: "tap";
+    role: string;
+    name: string;
+    nth: number;
+} | {
+    action: "type";
+    role: string;
+    name: string;
+    nth: number;
+    text: string;
+    enter?: boolean;
+} | {
+    action: "back";
+};
+export type Reply = {
+    ok: boolean;
+    screen?: string | null;
+    error?: string;
+    code?: string;
+    delivery?: string;
+    reason?: string;
+};
+/** What the walker needs from a simulator session. */
+export type Driver = {
+    /** Start a fresh phone on the app. */
+    open(): Promise<Reply>;
+    openUrl(url: string): Promise<Reply>;
+    tap(ref: string): Promise<Reply>;
+    back(): Promise<Reply>;
+    /** Type into a text field. Optional: without it the walker does not fill fields. `enter` presses Enter after the text. */
+    type?(ref: string, text: string, enter?: boolean): Promise<Reply>;
+    /** Look at the current screen again without acting. Optional: without it `stuck_loading` is not checked. */
+    snapshot?(): Promise<Reply>;
+    /** Uncaught page errors since the last call. */
+    errors(): Promise<string[]>;
+    /** Rendered size in px of each ref on the current screen. Optional: without it the size check is skipped. */
+    sizes?(): Promise<Record<string, [number, number]>>;
+};
+export type Skin = "android" | "ios";
+/** Smallest tap target: 44 x 44 pt on iOS (Apple HIG), 48 x 48 dp on Android (Material and Android accessibility guide). */
+export declare const MIN_TARGET: Record<Skin, number>;
+export type Kind = "error" | "not_delivered" | "action_failed" | "dead_end" | "unnamed" | "small_target" | "duplicate_name" | "network_failed" | "stuck_loading" | "blank_screen";
+export type Finding = {
+    kind: Kind;
+    message: string;
+    screen: string;
+    steps: Step[];
+};
+export type Report = {
+    app: string;
+    generatedAt: string;
+    steps: number;
+    screens: number;
+    maxSteps: number;
+    maxDepth: number;
+    stoppedEarly: string | null;
+    error: string | null;
+    findings: Finding[];
+    parityLimits: string[];
+};
+export declare const PARITY_LIMITS: string[];
+/** A value for a field, from its label: one the field should accept, or one it should reject. */
+export declare function sampleValue(name: string, invalid: boolean): string;
+type El = {
+    role: string;
+    name: string;
+    ref: string;
+    nth: number;
+};
+/** Actionable elements in a tree, in order. `nth` counts earlier elements with the same role and name. Disabled ones are left out. */
+export declare const elements: (tree: string) => El[];
+export declare const fieldElements: (tree: string) => El[];
+/** The tree without refs, to tell whether two screens are the same. */
+export declare const signature: (tree: string) => string;
+/** Steps in plain lines, for the report. */
+export declare const describeStep: (s: Step) => string;
+export type WalkOptions = {
+    routes?: string[];
+    onlyRoutes?: boolean;
+    maxDepth?: number;
+    maxSteps?: number;
+    app?: string;
+    skin?: Skin;
+    /** Seed for tie-breaks and tap order. The same seed on the same app repeats the same walk. Default 1. */
+    seed?: number;
+    /** Wait in ms between looks at a screen that shows a loading indicator. Default 400. */
+    settleMs?: number;
+    /** Start paths to walk instead of the app's start screen and `routes`. Used by `shipvo lumi` to test one flow. */
+    startPaths?: Step[][];
+    /** "bad": only try invalid values in text fields, and try them first. Default "both". */
+    input?: "both" | "bad";
+    /** Called as the walk goes: each action taken, each new screen, each new finding. */
+    onEvent?: (e: WalkEvent) => void;
+    /** Checked before every action. When it returns true the walk ends and says it was stopped. */
+    shouldStop?: () => boolean;
+};
+export type WalkEvent = {
+    type: "step";
+    n: number;
+    step: Step;
+    text: string;
+} | {
+    type: "screen";
+    screens: number;
+    sig: string;
+    controls: {
+        role: string;
+        name: string;
+    }[];
+} | {
+    type: "finding";
+    n: number;
+    finding: Finding;
+};
+/**
+ * Walks the app. Each round it picks the screen to work on with an upper confidence bound: screens with nothing tried yet
+ * come first, then screens whose taps found new screens, with a bonus for rarely tried ones. On that screen it takes safe actions
+ * before risky ones (log out, delete, cancel, remove). Text fields get a valid value, then an invalid one.
+ */
+export declare function walk(driver: Driver, o?: WalkOptions): Promise<Report>;
+export declare function renderMarkdown(r: Report): string;
+/** Driver for a running simulator. */
+export declare function simDriver(base: string, app: string, session?: string, platform?: Skin): Driver;
+/** Use the simulator at `--sim <url>`, or build the app and start one on `--port` (default 4546). `stop` kills the one we started. */
+export declare function startSim(a: Record<string, string | undefined>, cfg: {
+    name: string;
+    appId: string;
+    controlPlane: string;
+}, quiet?: boolean): Promise<{
+    base: string;
+    stop: () => void;
+}>;
+/** Returns the exit code. With `--json`, stdout is one envelope and everything else goes to stderr. */
+export declare function explore(argv: string[]): Promise<number>;
+/** The app's URL scheme: `expo.scheme` in app.json, else the scheme of a configured route such as "tide://cart". */
+export declare function appScheme(routes: string[] | undefined, dir?: string): string | undefined;
+/**
+ * Deep links to walk for `--changed-from <sha>`: the changed, routable screens (up to four), as `<scheme>://<screen>`.
+ * The walker opens them with the simulator's `open_url` action, which needs a URL the app's `onUrl` listener understands.
+ * If the diff cannot be read (for example a shallow checkout), or the app has no known scheme, say so and fall back to the full walk.
+ */
+export declare function routesFromChange(sha: string, log?: (s: string) => void, scheme?: string): Promise<{
+    routes?: string[];
+    onlyRoutes: boolean;
+}>;
+/** Exit code and `--json` code. A failed flow counts as a finding for `--fail-on-findings`; it has its own code when the walk found nothing. */
+export declare function outcome(report: {
+    error?: string | null;
+    findings: unknown[];
+}, flowsFailed: boolean, failOn: boolean): {
+    exit: number;
+    code: string;
+};
+export {};