taphound 0.2.0-dev.1 → 0.2.0-dev.11

package/dist/adapters/process/node-process-runner.js

@@ -35,6 +35,7 @@ export class NodeProcessRunner {
         let cancelled = false;
         let spawnError;
         let settled = false;
+        let terminationRequested = false;
         let timeout;
         let forceKillTimeout;
         let startupTimeout;
@@ -77,11 +78,15 @@ export class NodeProcessRunner {
         child.stdout.setEncoding("utf8");
         child.stderr.setEncoding("utf8");
         child.stdout.on("data", (chunk) => {
-            stdout += chunk;
+            if (handlers.captureStdout !== false) {
+                stdout += chunk;
+            }
             consumeLines(stdoutLines, chunk);
         });
         child.stderr.on("data", (chunk) => {
-            stderr += chunk;
+            if (handlers.captureStderr !== false) {
+                stderr += chunk;
+            }
             consumeLines(stderrLines, chunk);
         });
         child.on("spawn", () => {
@@ -137,6 +142,7 @@ export class NodeProcessRunner {
                     durationMs: performance.now() - startedAt,
                     timedOut,
                     cancelled,
+                    ...(terminationRequested ? { terminationRequested: true } : {}),
                     ...(spawnError === undefined ? {} : { spawnError })
                 };
                 settleStarted(result);
@@ -144,6 +150,9 @@ export class NodeProcessRunner {
             });
         });
         const stop = () => {
+            if (!settled) {
+                terminationRequested = true;
+            }
             terminate();
             return completion;
         };

package/dist/adapters/prompt/inquirer-align-prompt.d.ts

@@ -0,0 +1,27 @@
+import { confirm } from "@inquirer/prompts";
+import { type AlignPromptPort } from "../../ports/align-prompt.js";
+import type { CameraProbeResult } from "../../ports/camera-probe.js";
+export type AlignInputStream = NodeJS.ReadableStream & {
+    isTTY?: boolean | undefined;
+};
+export type AlignDiagnosticStream = NodeJS.WritableStream & {
+    isTTY?: boolean | undefined;
+};
+export type AlignPromptContext = NonNullable<Parameters<typeof confirm>[1]>;
+export interface AlignPromptFunctions {
+    confirm: (config: {
+        message: string;
+        default: boolean;
+    }, context: AlignPromptContext) => Promise<unknown>;
+}
+export declare class InquirerAlignPrompt implements AlignPromptPort {
+    private readonly prompts;
+    private readonly promptInput;
+    private readonly diagnostics;
+    constructor(prompts?: AlignPromptFunctions, promptInput?: AlignInputStream, diagnostics?: AlignDiagnosticStream);
+    confirmWrite(input: {
+        values: CameraProbeResult;
+        targetPath: string;
+    }): Promise<boolean>;
+    private assertLocalTty;
+}

package/dist/adapters/prompt/inquirer-align-prompt.js

@@ -0,0 +1,65 @@
+import { confirm } from "@inquirer/prompts";
+import { AlignPromptCancelledError } from "../../ports/align-prompt.js";
+const defaultPrompts = {
+    confirm: async (config, context) => confirm(config, context)
+};
+function formatValues(values) {
+    const lines = [
+        `  Camera package:    ${values.packageName}`,
+        `  Camera activity:   ${values.activityName}`,
+        ...(values.confirmActivityName === undefined
+            ? []
+            : [`  Review activity:   ${values.confirmActivityName}`]),
+        `  Shutter button:    ${values.shutterResourceId}${values.shutterContentDescription !== undefined
+            ? `  (${values.shutterContentDescription})`
+            : ""}`
+    ];
+    if (values.confirmResourceId !== undefined) {
+        lines.push(`  Confirm button:    ${values.confirmResourceId}${values.confirmContentDescription !== undefined
+            ? `  (${values.confirmContentDescription})`
+            : ""}`);
+    }
+    else {
+        lines.push("  Confirm button:    (none — camera auto-accepts)");
+    }
+    return lines.join("\n");
+}
+export class InquirerAlignPrompt {
+    prompts;
+    promptInput;
+    diagnostics;
+    constructor(prompts = defaultPrompts, promptInput = process.stdin, diagnostics = process.stderr) {
+        this.prompts = prompts;
+        this.promptInput = promptInput;
+        this.diagnostics = diagnostics;
+    }
+    async confirmWrite(input) {
+        this.assertLocalTty();
+        const body = formatValues(input.values);
+        let answer;
+        try {
+            answer = await this.prompts.confirm({
+                message: `${body}\n\nWrite flow to ${input.targetPath}?`,
+                default: true
+            }, { input: this.promptInput, output: this.diagnostics });
+        }
+        catch (error) {
+            if (error instanceof Error
+                && (error.name === "AbortPromptError"
+                    || error.name === "ExitPromptError")) {
+                throw new AlignPromptCancelledError();
+            }
+            throw error;
+        }
+        if (typeof answer !== "boolean") {
+            throw new Error("Align confirm prompt returned an invalid answer");
+        }
+        return answer;
+    }
+    assertLocalTty() {
+        if (this.promptInput.isTTY !== true
+            || this.diagnostics.isTTY !== true) {
+            throw new Error("Align confirm requires local TTY input and diagnostics");
+        }
+    }
+}

package/dist/adapters/prompt/inquirer-generation-prompt.js

@@ -58,6 +58,9 @@ export class InquirerGenerationPrompt {
             throw new Error("Generation confirmation challenge is not pending");
         }
         this.diagnostics.write(`TapHound confirmation: ${challenge.actionSummary}\n`);
+        if (challenge.reason !== undefined) {
+            this.diagnostics.write(`Reason (${challenge.reason.rule}): ${challenge.reason.message}\n`);
+        }
         const answer = await this.ask((context) => this.prompts.confirm({
             message: `Approve action at step ${String(challenge.stepIndex)}?`,
             default: false

package/dist/adapters/prompt/inquirer-recorder-prompt.d.ts

@@ -1,4 +1,5 @@
-import type { RecorderAction, RecorderPromptPort, RecorderTargetChoice, ScrollDecision, SwipeOptions } from "../../ports/recorder-prompt.js";
+import type { BridgeScenario } from "../../domain/journey.js";
+import type { ExternalStepAction, RecorderAction, RecorderPromptPort, RecorderTargetChoice, ScrollDecision, SwipeOptions } from "../../ports/recorder-prompt.js";
 interface SelectConfig {
     message: string;
     choices: readonly {
@@ -43,5 +44,12 @@ export declare class InquirerRecorderPrompt implements RecorderPromptPort {
     notifyFailure(message: string): Promise<void>;
     selectScrollContainer(choices: readonly RecorderTargetChoice[]): Promise<string>;
     scrollTargetDecision(choices: readonly RecorderTargetChoice[]): Promise<ScrollDecision>;
+    selectBridgeScenario(): Promise<BridgeScenario>;
+    inputBridgeDescription(scenario: BridgeScenario): Promise<string>;
+    inputBridgeReturnTimeoutMs(): Promise<number>;
+    selectExternalStepAction(): Promise<ExternalStepAction>;
+    notifyExternalEscape(escapedPackageName: string): Promise<void>;
+    notifyExternalReturn(): Promise<void>;
+    notifyBridgeNoEscape(): Promise<void>;
 }
 export {};

package/dist/adapters/prompt/inquirer-recorder-prompt.js

@@ -19,9 +19,26 @@ const ACTIONS = [
     "scrollTo",
     "back",
     "wait",
+    "bridgeTrigger",
     "finish",
     "cancel"
 ];
+const EXTERNAL_STEP_ACTIONS = [
+    "click",
+    "longClick",
+    "inputText",
+    "swipe",
+    "scrollTo",
+    "back",
+    "wait",
+    "finishExternal"
+];
+const BRIDGE_SCENARIOS = [
+    "photoCapture",
+    "pickImage",
+    "pickFile",
+    "custom"
+];
 function selectedString(value, allowed) {
     if (typeof value !== "string"
         || (allowed !== undefined && !allowed.includes(value))) {
@@ -154,4 +171,50 @@ export class InquirerRecorderPrompt {
         }
         return { kind: "select", id: selected };
     }
+    async selectBridgeScenario() {
+        const value = await this.prompts.select({
+            message: "Bridge scenario",
+            choices: BRIDGE_SCENARIOS.map((scenario) => ({
+                name: scenario,
+                value: scenario
+            }))
+        });
+        return selectedString(value, BRIDGE_SCENARIOS);
+    }
+    async inputBridgeDescription(scenario) {
+        const value = await this.prompts.input({
+            message: `Bridge description${scenario === "custom" ? " (required)" : ""}`,
+            validate: (answer) => answer.trim().length > 0 || "Description must not be empty"
+        });
+        return selectedString(value);
+    }
+    async inputBridgeReturnTimeoutMs() {
+        return selectedNumber(await this.prompts.number({
+            message: "Return timeout (ms)",
+            default: 30000,
+            min: 1
+        }), 1);
+    }
+    async selectExternalStepAction() {
+        const value = await this.prompts.select({
+            message: "Choose an external App Action",
+            choices: EXTERNAL_STEP_ACTIONS.map((action) => ({
+                name: action,
+                value: action
+            }))
+        });
+        return selectedString(value, EXTERNAL_STEP_ACTIONS);
+    }
+    notifyExternalEscape(escapedPackageName) {
+        this.diagnostics.write(`TapHound: Package escape detected — ${escapedPackageName}\n`);
+        return Promise.resolve();
+    }
+    notifyExternalReturn() {
+        this.diagnostics.write("TapHound: Returned to target package\n");
+        return Promise.resolve();
+    }
+    notifyBridgeNoEscape() {
+        this.diagnostics.write("TapHound: Trigger did not cause a package escape; bridge step was not recorded\n");
+        return Promise.resolve();
+    }
 }

package/dist/adapters/runtime/adb-runtime-backend.d.ts

@@ -0,0 +1,67 @@
+import type { AdbPort, DeviceIdentity } from "../../ports/adb.js";
+import type { AnnotatedScreenResolverPort } from "../../ports/annotated-screen-resolver.js";
+import type { CommandResult, RunningCommand } from "../../ports/process-runner.js";
+import type { OpenRuntimeSessionOptions, OpenRuntimeUiSnapshotsOptions, RuntimeAppQuery, RuntimeBackend, RuntimeDumpLogcatOptions, RuntimeIntentOptions, RuntimeLaunchOptions, RuntimeLogcatStreamOptions, RuntimeScreenshotOptions, RuntimeSession } from "../../ports/runtime-backend.js";
+import type { ScreenshotPort } from "../../ports/screenshot.js";
+import type { UiSnapshotProvider, UiSnapshotProviderFactory } from "../../ports/ui-snapshot.js";
+import type { UiStabilityProbe } from "../../ports/ui-stability.js";
+import type { ForegroundComponent } from "../../domain/activity.js";
+import type { AppProcess } from "../../domain/app-process.js";
+import type { Point } from "../../domain/geometry.js";
+import type { DeviceInfo, RuntimeBackendDescriptor, RuntimeCapabilities } from "../../domain/runtime.js";
+import type { WindowTopology } from "../../domain/window-hierarchy.js";
+export declare const ADB_RUNTIME_ADAPTER_VERSION = "adb-runtime-v1";
+export declare const DEFAULT_RUNTIME_UI_SNAPSHOT_TIMEOUT_MS = 5000;
+export declare function adbRuntimeCapabilities(): RuntimeCapabilities;
+export interface AdbRuntimeSessionDependencies {
+    adb: AdbPort;
+    screenshots: ScreenshotPort;
+    annotatedScreens: AnnotatedScreenResolverPort;
+    uiStability: UiStabilityProbe;
+    uiSnapshotFactory: UiSnapshotProviderFactory;
+    deviceSerial: string;
+    descriptor: RuntimeBackendDescriptor;
+}
+export declare class AdbRuntimeSession implements RuntimeSession {
+    private readonly dependencies;
+    private uiSnapshotProvider;
+    constructor(dependencies: AdbRuntimeSessionDependencies);
+    get descriptor(): RuntimeBackendDescriptor;
+    get deviceSerial(): string;
+    get deviceIdentity(): ((app: RuntimeAppQuery) => Promise<DeviceIdentity>) | undefined;
+    openUiSnapshots(options?: OpenRuntimeUiSnapshotsOptions): Promise<UiSnapshotProvider>;
+    get annotatedScreens(): AnnotatedScreenResolverPort;
+    get uiStability(): UiStabilityProbe;
+    isInstalled(app: RuntimeAppQuery): Promise<boolean>;
+    launchApp(options: RuntimeLaunchOptions): Promise<CommandResult>;
+    forceStop(app: RuntimeAppQuery): Promise<CommandResult>;
+    currentActivity(app: RuntimeAppQuery): Promise<string>;
+    foregroundComponent(app: RuntimeAppQuery): Promise<ForegroundComponent>;
+    appProcesses(app: RuntimeAppQuery): Promise<readonly AppProcess[]>;
+    windowTopology(app: RuntimeAppQuery): Promise<WindowTopology>;
+    tap(point: Point, signal?: AbortSignal): Promise<CommandResult>;
+    longClick(point: Point, durationMs: number, signal?: AbortSignal): Promise<CommandResult>;
+    swipe(from: Point, to: Point, durationMs: number, signal?: AbortSignal): Promise<CommandResult>;
+    back(signal?: AbortSignal): Promise<CommandResult>;
+    inputText(text: string, signal?: AbortSignal): Promise<CommandResult>;
+    startLogcat(options: RuntimeLogcatStreamOptions): RunningCommand;
+    dumpLogcat(options: RuntimeDumpLogcatOptions): Promise<CommandResult>;
+    captureScreenshot(options: RuntimeScreenshotOptions): Promise<CommandResult>;
+    startActivityByIntent(options: RuntimeIntentOptions): Promise<CommandResult>;
+    close(): Promise<void>;
+}
+export interface AdbRuntimeBackendDependencies {
+    adb: AdbPort;
+    screenshots: ScreenshotPort;
+    annotatedScreens: AnnotatedScreenResolverPort;
+    uiStability: UiStabilityProbe;
+    uiSnapshots: UiSnapshotProviderFactory;
+}
+export declare class AdbRuntimeBackend implements RuntimeBackend {
+    private readonly dependencies;
+    readonly descriptor: RuntimeBackendDescriptor;
+    readonly capabilities: RuntimeCapabilities;
+    constructor(dependencies: AdbRuntimeBackendDependencies);
+    listDevices(signal?: AbortSignal): Promise<readonly DeviceInfo[]>;
+    openSession(options: OpenRuntimeSessionOptions): Promise<RuntimeSession>;
+}

package/dist/adapters/runtime/adb-runtime-backend.js

@@ -0,0 +1,206 @@
+import { createHash } from "node:crypto";
+export const ADB_RUNTIME_ADAPTER_VERSION = "adb-runtime-v1";
+export const DEFAULT_RUNTIME_UI_SNAPSHOT_TIMEOUT_MS = 5000;
+export function adbRuntimeCapabilities() {
+    return {
+        layoutSnapshot: true,
+        screenshot: true,
+        annotatedScreens: true,
+        frameStatsIdle: true,
+        logs: true,
+        processDiscovery: true,
+        windowTopology: true,
+        intentStart: true,
+        foregroundActivity: true
+    };
+}
+function appIdentity(query, deviceSerial) {
+    return {
+        packageName: query.packageName,
+        deviceSerial,
+        ...(query.signal === undefined ? {} : { signal: query.signal }),
+        ...(query.timeoutMs === undefined ? {} : { timeoutMs: query.timeoutMs })
+    };
+}
+export class AdbRuntimeSession {
+    dependencies;
+    uiSnapshotProvider;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    get descriptor() {
+        return this.dependencies.descriptor;
+    }
+    get deviceSerial() {
+        return this.dependencies.deviceSerial;
+    }
+    get deviceIdentity() {
+        if (this.dependencies.adb.deviceIdentity === undefined) {
+            return undefined;
+        }
+        return (app) => {
+            const current = this.dependencies.adb.deviceIdentity;
+            if (current === undefined) {
+                return Promise.reject(new Error("deviceIdentity is unavailable"));
+            }
+            return current.call(this.dependencies.adb, appIdentity(app, this.dependencies.deviceSerial));
+        };
+    }
+    openUiSnapshots(options) {
+        if (this.uiSnapshotProvider !== undefined) {
+            return this.uiSnapshotProvider;
+        }
+        const opened = this.dependencies.uiSnapshotFactory.open({
+            deviceSerial: this.dependencies.deviceSerial,
+            timeoutMs: options?.timeoutMs
+                ?? DEFAULT_RUNTIME_UI_SNAPSHOT_TIMEOUT_MS,
+            ...(options?.backend === undefined
+                ? {}
+                : { backend: options.backend }),
+            ...(options?.cacheEnabled === undefined
+                ? {}
+                : { cacheEnabled: options.cacheEnabled }),
+            ...(options?.signal === undefined ? {} : { signal: options.signal })
+        });
+        opened.catch(() => {
+            if (this.uiSnapshotProvider === opened) {
+                this.uiSnapshotProvider = undefined;
+            }
+        });
+        this.uiSnapshotProvider = opened;
+        return opened;
+    }
+    get annotatedScreens() {
+        return this.dependencies.annotatedScreens;
+    }
+    get uiStability() {
+        return this.dependencies.uiStability;
+    }
+    isInstalled(app) {
+        return this.dependencies.adb.isInstalled(appIdentity(app, this.dependencies.deviceSerial));
+    }
+    launchApp(options) {
+        return this.dependencies.adb.launchActivity({
+            packageName: options.packageName,
+            activity: options.activity,
+            deviceSerial: this.dependencies.deviceSerial,
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
+            ...(options.timeoutMs === undefined
+                ? {}
+                : { timeoutMs: options.timeoutMs })
+        });
+    }
+    forceStop(app) {
+        return this.dependencies.adb.forceStop(appIdentity(app, this.dependencies.deviceSerial));
+    }
+    currentActivity(app) {
+        return this.dependencies.adb.currentActivity(appIdentity(app, this.dependencies.deviceSerial));
+    }
+    foregroundComponent(app) {
+        return this.dependencies.adb.foregroundComponent(appIdentity(app, this.dependencies.deviceSerial));
+    }
+    appProcesses(app) {
+        return this.dependencies.adb.appProcesses(appIdentity(app, this.dependencies.deviceSerial));
+    }
+    windowTopology(app) {
+        return this.dependencies.adb.windowTopology(appIdentity(app, this.dependencies.deviceSerial));
+    }
+    tap(point, signal) {
+        return this.dependencies.adb.tap(point, this.dependencies.deviceSerial, signal);
+    }
+    longClick(point, durationMs, signal) {
+        return this.dependencies.adb.longClick(point, durationMs, this.dependencies.deviceSerial, signal);
+    }
+    swipe(from, to, durationMs, signal) {
+        return this.dependencies.adb.swipe(from, to, durationMs, this.dependencies.deviceSerial, signal);
+    }
+    back(signal) {
+        return this.dependencies.adb.back(this.dependencies.deviceSerial, signal);
+    }
+    inputText(text, signal) {
+        return this.dependencies.adb.inputText(text, this.dependencies.deviceSerial, signal);
+    }
+    startLogcat(options) {
+        return this.dependencies.adb.startLogcat({
+            deviceSerial: this.dependencies.deviceSerial,
+            onStdoutLine: options.onStdoutLine,
+            ...(options.onStderrLine === undefined
+                ? {}
+                : { onStderrLine: options.onStderrLine }),
+            ...(options.signal === undefined ? {} : { signal: options.signal })
+        });
+    }
+    dumpLogcat(options) {
+        return this.dependencies.adb.dumpLogcat({
+            deviceSerial: this.dependencies.deviceSerial,
+            maxLines: options.maxLines,
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
+            ...(options.timeoutMs === undefined
+                ? {}
+                : { timeoutMs: options.timeoutMs })
+        });
+    }
+    captureScreenshot(options) {
+        return this.dependencies.screenshots.capture({
+            outputPath: options.outputPath,
+            deviceSerial: this.dependencies.deviceSerial,
+            ...(options.annotate === undefined ? {} : { annotate: options.annotate }),
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
+            ...(options.timeoutMs === undefined
+                ? {}
+                : { timeoutMs: options.timeoutMs })
+        });
+    }
+    startActivityByIntent(options) {
+        return this.dependencies.adb.startActivityByIntent({
+            action: options.action,
+            deviceSerial: this.dependencies.deviceSerial,
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
+            ...(options.timeoutMs === undefined
+                ? {}
+                : { timeoutMs: options.timeoutMs })
+        });
+    }
+    close() {
+        const provider = this.uiSnapshotProvider;
+        if (provider === undefined) {
+            return Promise.resolve();
+        }
+        this.uiSnapshotProvider = undefined;
+        return provider.then((snapshotProvider) => snapshotProvider.close(), () => undefined);
+    }
+}
+export class AdbRuntimeBackend {
+    dependencies;
+    descriptor;
+    capabilities = adbRuntimeCapabilities();
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+        const capabilities = adbRuntimeCapabilities();
+        this.capabilities = capabilities;
+        this.descriptor = {
+            id: "adb",
+            adapterVersion: ADB_RUNTIME_ADAPTER_VERSION,
+            configSha256: createHash("sha256").update(JSON.stringify({
+                id: "adb",
+                adapterVersion: ADB_RUNTIME_ADAPTER_VERSION,
+                capabilities
+            })).digest("hex"),
+            capabilities
+        };
+    }
+    listDevices(signal) {
+        return this.dependencies.adb.devices(signal);
+    }
+    openSession(options) {
+        return Promise.resolve(new AdbRuntimeSession({
+            adb: this.dependencies.adb,
+            screenshots: this.dependencies.screenshots,
+            annotatedScreens: this.dependencies.annotatedScreens,
+            uiStability: this.dependencies.uiStability,
+            uiSnapshotFactory: this.dependencies.uiSnapshots,
+            deviceSerial: options.deviceSerial,
+            descriptor: this.descriptor
+        }));
+    }
+}

package/dist/adapters/runtime/fake-runtime-backend.d.ts

@@ -0,0 +1,87 @@
+import type { DeviceIdentity } from "../../ports/adb.js";
+import type { AnnotatedScreenResolverPort } from "../../ports/annotated-screen-resolver.js";
+import type { CommandResult, RunningCommand } from "../../ports/process-runner.js";
+import type { OpenRuntimeSessionOptions, OpenRuntimeUiSnapshotsOptions, RuntimeAppQuery, RuntimeBackend, RuntimeDumpLogcatOptions, RuntimeIntentOptions, RuntimeLaunchOptions, RuntimeLogcatStreamOptions, RuntimeScreenshotOptions, RuntimeSession } from "../../ports/runtime-backend.js";
+import type { UiSnapshotProvider } from "../../ports/ui-snapshot.js";
+import type { UiStabilityProbe } from "../../ports/ui-stability.js";
+import type { ForegroundComponent } from "../../domain/activity.js";
+import type { AppProcess } from "../../domain/app-process.js";
+import type { DeviceInfo, RuntimeBackendDescriptor, RuntimeCapabilities } from "../../domain/runtime.js";
+import type { WindowTopology } from "../../domain/window-hierarchy.js";
+export declare const FAKE_RUNTIME_ADAPTER_VERSION = "fake-runtime-v1";
+export declare function fakeRuntimeCapabilities(): RuntimeCapabilities;
+export declare function fakeRuntimeUiSnapshotProvider(provider?: Partial<UiSnapshotProvider>): UiSnapshotProvider;
+export interface FakeRuntimeSessionState {
+    installed?: boolean | undefined;
+    foreground?: ForegroundComponent | undefined;
+    processes?: readonly AppProcess[] | undefined;
+    topology?: WindowTopology | undefined;
+    currentActivity?: string | undefined;
+    dumpLogcatResult?: CommandResult | undefined;
+}
+export declare class FakeRuntimeSession implements RuntimeSession {
+    readonly descriptor: RuntimeBackendDescriptor;
+    readonly deviceSerial: string;
+    readonly uiSnapshotProvider: UiSnapshotProvider;
+    readonly capabilities: RuntimeCapabilities;
+    readonly currentActivity: ((app: RuntimeAppQuery) => Promise<string>) | undefined;
+    readonly deviceIdentity: ((app: RuntimeAppQuery) => Promise<DeviceIdentity>) | undefined;
+    readonly foregroundComponent: ((app: RuntimeAppQuery) => Promise<ForegroundComponent>) | undefined;
+    readonly appProcesses: ((app: RuntimeAppQuery) => Promise<readonly AppProcess[]>) | undefined;
+    readonly windowTopology: ((app: RuntimeAppQuery) => Promise<WindowTopology>) | undefined;
+    readonly startLogcat: ((options: RuntimeLogcatStreamOptions) => RunningCommand) | undefined;
+    readonly dumpLogcat: ((options: RuntimeDumpLogcatOptions) => Promise<CommandResult>) | undefined;
+    annotatedScreens: AnnotatedScreenResolverPort | undefined;
+    uiStability: UiStabilityProbe;
+    startActivityByIntent: ((options: RuntimeIntentOptions) => Promise<CommandResult>) | undefined;
+    state: FakeRuntimeSessionState;
+    readonly calls: string[];
+    lastUiSnapshotOptions: OpenRuntimeUiSnapshotsOptions | undefined;
+    private openedUiSnapshots;
+    constructor(input: {
+        descriptor: RuntimeBackendDescriptor;
+        deviceSerial: string;
+        state?: FakeRuntimeSessionState | undefined;
+        uiSnapshots?: UiSnapshotProvider | undefined;
+        uiStability?: UiStabilityProbe | undefined;
+        deviceIdentity?: DeviceIdentity | undefined;
+    });
+    openUiSnapshots(options?: OpenRuntimeUiSnapshotsOptions): Promise<UiSnapshotProvider>;
+    isInstalled(app: RuntimeAppQuery): Promise<boolean>;
+    launchApp(options: RuntimeLaunchOptions): Promise<CommandResult>;
+    forceStop(app: RuntimeAppQuery): Promise<CommandResult>;
+    tap(point: {
+        x: number;
+        y: number;
+    }): Promise<CommandResult>;
+    longClick(point: {
+        x: number;
+        y: number;
+    }, durationMs: number): Promise<CommandResult>;
+    swipe(from: {
+        x: number;
+        y: number;
+    }, to: {
+        x: number;
+        y: number;
+    }, durationMs: number): Promise<CommandResult>;
+    back(): Promise<CommandResult>;
+    inputText(text: string): Promise<CommandResult>;
+    captureScreenshot(options: RuntimeScreenshotOptions): Promise<CommandResult>;
+    close(): Promise<void>;
+}
+export declare class FakeRuntimeBackend implements RuntimeBackend {
+    readonly descriptor: RuntimeBackendDescriptor;
+    readonly capabilities: RuntimeCapabilities;
+    readonly devices: readonly DeviceInfo[];
+    readonly openCalls: OpenRuntimeSessionOptions[];
+    readonly sessions: FakeRuntimeSession[];
+    createSession: (options: OpenRuntimeSessionOptions) => RuntimeSession;
+    constructor(options?: {
+        capabilities?: RuntimeCapabilities | undefined;
+        devices?: readonly DeviceInfo[] | undefined;
+        sessions?: ((options: OpenRuntimeSessionOptions) => RuntimeSession) | undefined;
+    });
+    listDevices(): Promise<readonly DeviceInfo[]>;
+    openSession(options: OpenRuntimeSessionOptions): Promise<RuntimeSession>;
+}