taphound 0.2.0-dev.1 → 0.2.0-dev.12

package/dist/cli/diagnostics-recorder.d.ts

@@ -0,0 +1,31 @@
+import type { Command } from "commander";
+import { type CommandEvent, type DiagnosticsHostSchema } from "../domain/diagnostics.js";
+import type { UiCaptureTelemetry } from "../application/diagnostics/ui-capture-telemetry.js";
+import type { DiagnosticsJournal } from "../ports/diagnostics.js";
+import type { z } from "zod";
+export interface CliDiagnostics {
+    journal: DiagnosticsJournal;
+    telemetry: UiCaptureTelemetry;
+}
+export declare function diagnosticsEnabled(env: Record<string, string | undefined>): boolean;
+export declare function diagnosticsHost(): z.infer<typeof DiagnosticsHostSchema>;
+/** What the invoked command is, captured before its action runs. */
+export interface InvokedCommand {
+    command: string;
+    flags: string[];
+    projectRoot: string;
+}
+export declare function describeInvocation(action: Command, cwd: string): InvokedCommand;
+/**
+ * Reads only the structured outcome of one machine-readable output: status,
+ * failure code, and run id. Messages and every other field are ignored.
+ */
+export declare function outcomeFromJsonOutput(stdout: string): Pick<CommandEvent, "status" | "failureCode" | "runId">;
+export declare function commandEvent(input: {
+    invocation: InvokedCommand;
+    startedAt: Date;
+    durationMs: number;
+    exitCode: number;
+    stdout: string | undefined;
+    telemetry: UiCaptureTelemetry;
+}): CommandEvent;

package/dist/cli/diagnostics-recorder.js

@@ -0,0 +1,82 @@
+import { arch, platform, version as nodeVersion } from "node:process";
+import { resolve } from "node:path";
+import { CommandEventSchema, DIAGNOSTICS_DISABLE_ENV_VAR } from "../domain/diagnostics.js";
+import { FAILURE_CODES } from "../domain/failure.js";
+import { readCliVersion } from "./version.js";
+export function diagnosticsEnabled(env) {
+    const value = env[DIAGNOSTICS_DISABLE_ENV_VAR]?.trim().toLowerCase();
+    return !["0", "off", "false", "no"].includes(value ?? "");
+}
+export function diagnosticsHost() {
+    return {
+        platform,
+        arch,
+        node: nodeVersion.replace(/^v/, "")
+    };
+}
+export function describeInvocation(action, cwd) {
+    const names = [];
+    let command = action;
+    while (command.parent !== null) {
+        names.unshift(command.name());
+        command = command.parent;
+    }
+    const flags = action.options
+        .map((option) => option.attributeName())
+        .filter((name) => action.getOptionValueSource(name) === "cli");
+    const project = action.opts().project;
+    return {
+        command: names.join(" "),
+        flags,
+        projectRoot: typeof project === "string" ? resolve(cwd, project) : cwd
+    };
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function failureCode(value) {
+    return FAILURE_CODES.find((code) => code === value);
+}
+/**
+ * Reads only the structured outcome of one machine-readable output: status,
+ * failure code, and run id. Messages and every other field are ignored.
+ */
+export function outcomeFromJsonOutput(stdout) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout.trim());
+    }
+    catch {
+        return {};
+    }
+    const output = record(parsed);
+    if (output === undefined)
+        return {};
+    const report = record(output.report);
+    const status = [output.status, output.verdict].find((value) => (typeof value === "string" && /^[a-zA-Z][a-zA-Z\d]{0,31}$/.test(value)));
+    const code = failureCode(record(output.failure)?.code)
+        ?? failureCode(record(report?.primaryFailure)?.code);
+    const runId = [report?.runId, output.runId].find((value) => (typeof value === "string" && /^[\w.-]{1,128}$/.test(value)));
+    return {
+        ...(typeof status === "string" ? { status } : {}),
+        ...(code === undefined ? {} : { failureCode: code }),
+        ...(typeof runId === "string" ? { runId } : {})
+    };
+}
+export function commandEvent(input) {
+    return CommandEventSchema.parse({
+        version: 1,
+        kind: "command",
+        at: input.startedAt.toISOString(),
+        taphoundVersion: readCliVersion(),
+        host: diagnosticsHost(),
+        command: input.invocation.command,
+        flags: input.invocation.flags,
+        durationMs: Math.max(0, Math.round(input.durationMs)),
+        exitCode: input.exitCode,
+        ...(input.stdout === undefined ? {} : outcomeFromJsonOutput(input.stdout)),
+        ui: input.telemetry.summary()
+    });
+}

package/dist/cli/diff-verification.d.ts

@@ -0,0 +1,41 @@
+import type { ImpactSet } from "../domain/impact.js";
+import { CONFIG_PATH } from "../domain/workspace.js";
+import { type FailureCode } from "../domain/failure.js";
+import type { CliDependencies } from "./dependencies.js";
+export interface DiffVerificationOptions {
+    project: string;
+    config: string;
+    base: string;
+    head?: string | undefined;
+    device?: string | undefined;
+    scope?: string | undefined;
+    json?: boolean | undefined;
+}
+export interface JourneyVerdict {
+    path: string;
+    name: string;
+    selection: "p0" | "p1" | "p2";
+    status: string;
+    exitCode: 0 | 1 | 2 | 3 | 4;
+    reportPath: string;
+}
+export interface DiffVerificationResult {
+    base: string;
+    head: string;
+    impact: ImpactSet;
+    results: JourneyVerdict[];
+    overall: "passed" | "failed" | "error";
+    exitCode: 0 | 1 | 2 | 3 | 4;
+    note?: string | undefined;
+}
+declare function writeFailure(dependencies: CliDependencies, json: boolean, code: FailureCode, message: string): void;
+/**
+ * Diff-driven verification: compute the ImpactSet for a Git change, select
+ * the affected Journeys by tier (p0/p1/p2), and verify each one on the
+ * connected device.
+ *
+ * This is the Agent-facing entry behind `verify --diff`; it never parses the app's internals — the Coding Agent
+ * only sees Journey names + verdicts.
+ */
+export declare function runDiffVerification(dependencies: CliDependencies, options: DiffVerificationOptions): Promise<void>;
+export { CONFIG_PATH, writeFailure };

package/dist/cli/diff-verification.js

@@ -0,0 +1,192 @@
+import { resolve } from "node:path";
+import { TapHoundConfigSchema } from "../domain/config.js";
+import { DEFAULT_DEVICE_ROLE, JourneySchema } from "../domain/journey.js";
+import { assertArtifactDirectory, CONFIG_PATH } from "../domain/workspace.js";
+import { exitCodeForFailure, failureCodeFromUnknown } from "../domain/failure.js";
+import { errorMessage, failureOutput, writeJson, writeLine } from "./output.js";
+import { prepareWorkspace } from "./workspace-guard.js";
+function selectedScopes(scope) {
+    const normalized = scope ?? "p0,p1";
+    const tiers = [];
+    for (const token of normalized.split(",").map((value) => value.trim())) {
+        if (token === "p0" || token === "p1" || token === "p2") {
+            tiers.push(token);
+        }
+    }
+    return tiers;
+}
+function toolVersions(checks) {
+    return Object.fromEntries(checks.flatMap((check) => (check.version === undefined
+        || !["node", "adb", "android"].includes(check.name)
+        ? []
+        : [[check.name, check.version]])));
+}
+function writeFailure(dependencies, json, code, message) {
+    const exitCode = exitCodeForFailure(code);
+    const output = failureOutput(exitCode, code, message);
+    if (json) {
+        writeJson(dependencies.stdout, output);
+    }
+    else {
+        writeLine(dependencies.stderr, output.failure.message);
+    }
+    dependencies.setExitCode(exitCode);
+}
+/**
+ * Diff-driven verification: compute the ImpactSet for a Git change, select
+ * the affected Journeys by tier (p0/p1/p2), and verify each one on the
+ * connected device.
+ *
+ * This is the Agent-facing entry behind `verify --diff`; it never parses the app's internals — the Coding Agent
+ * only sees Journey names + verdicts.
+ */
+export async function runDiffVerification(dependencies, options) {
+    try {
+        if (dependencies.gitDiff === undefined
+            || dependencies.impact === undefined) {
+            throw new Error("TapHound change verification is not configured");
+        }
+        const head = options.head ?? "HEAD";
+        const projectRoot = options.project;
+        const config = TapHoundConfigSchema.parse(await dependencies.readJson(resolve(projectRoot, options.config)));
+        assertArtifactDirectory(projectRoot, config.artifactsDir);
+        await prepareWorkspace(dependencies, projectRoot);
+        const changeSet = await dependencies.gitDiff.diff({
+            projectRoot,
+            base: options.base,
+            head
+        });
+        const impact = await dependencies.impact.resolve({
+            projectRoot,
+            packageName: config.run.packageName,
+            changeSet
+        });
+        const scopes = selectedScopes(options.scope);
+        const selected = scopes.flatMap((tier) => (impact.selectedJourneys[tier].map((entry) => ({
+            tier,
+            path: entry.id
+        }))));
+        const doctor = await dependencies.doctor.run({
+            packageName: config.run.packageName,
+            ...(config.ui?.backend === undefined
+                ? {}
+                : { requestedUiBackend: config.ui.backend }),
+            ...(options.device === undefined
+                ? {}
+                : { requestedDevice: options.device }),
+            ...(dependencies.signal === undefined
+                ? {}
+                : { signal: dependencies.signal })
+        });
+        if (doctor.status === "failed") {
+            const output = failureOutput(3, doctor.failureCode ?? "ENVIRONMENT_MISSING_TOOL", doctor.checks.find((check) => check.status === "failed")?.message
+                ?? "TapHound environment preflight failed");
+            if (options.json === true) {
+                writeJson(dependencies.stdout, output);
+            }
+            else {
+                writeLine(dependencies.stderr, output.failure.message);
+            }
+            dependencies.setExitCode(3);
+            return;
+        }
+        const deviceSerial = options.device ?? doctor.deviceSerial;
+        if (deviceSerial === undefined) {
+            throw new Error("Doctor did not select a device");
+        }
+        if (dependencies.journeyCompositionStore === undefined) {
+            throw new Error("TapHound change verification is not configured");
+        }
+        const results = [];
+        for (const entry of selected) {
+            const bytes = await dependencies.journeyCompositionStore.read({
+                projectRoot,
+                relativePath: entry.path
+            });
+            const journey = JourneySchema.parse(JSON.parse(bytes.toString("utf8")));
+            if (journey.devices.length > 1) {
+                writeFailure(dependencies, options.json === true, "DEVICE_ROLE_UNMAPPED", `Journey ${journey.name} declares multiple devices; map each role with --device <role>=<serial>`);
+                return;
+            }
+            writeLine(dependencies.stderr, `TapHound: verifying ${journey.name} (${entry.tier})`);
+            const result = await dependencies.verifier.verify({
+                config,
+                journey,
+                projectRoot,
+                devices: [{
+                        role: journey.devices[0]?.role ?? DEFAULT_DEVICE_ROLE,
+                        deviceSerial
+                    }],
+                toolVersions: toolVersions(doctor.checks),
+                manualReplay: process.stdin.isTTY,
+                ...(dependencies.signal === undefined
+                    ? {}
+                    : { signal: dependencies.signal })
+            });
+            results.push({
+                path: entry.path,
+                name: journey.name,
+                selection: entry.tier,
+                status: result.status,
+                exitCode: result.exitCode,
+                reportPath: result.reportPath
+            });
+        }
+        const failed = results.find((result) => result.status !== "passed");
+        let overall;
+        let note;
+        if (changeSet.files.length === 0) {
+            overall = "passed";
+            note = "No changes; nothing to verify";
+        }
+        else {
+            overall = results.length === 0
+                ? "error"
+                : failed === undefined
+                    ? "passed"
+                    : "failed";
+        }
+        const exitCode = results.length === 0
+            ? (changeSet.files.length === 0 ? 0 : 4)
+            : failed === undefined
+                ? 0
+                : failed.exitCode;
+        const payload = {
+            base: options.base,
+            head,
+            impact,
+            results,
+            overall,
+            exitCode,
+            ...(note === undefined ? {} : { note })
+        };
+        if (options.json === true) {
+            writeJson(dependencies.stdout, payload);
+        }
+        else {
+            const lines = [
+                `TapHound verify (${options.base}...${head}):`,
+                ...results.map((result) => (`  ${result.selection.toUpperCase()} ${result.name}: ${result.status.toUpperCase()}`)),
+                `overall: ${overall.toUpperCase()}`
+            ];
+            writeLine(dependencies.stdout, lines.join("\n"));
+        }
+        dependencies.setExitCode(exitCode);
+    }
+    catch (error) {
+        const code = failureCodeFromUnknown(error);
+        if (code !== undefined) {
+            writeFailure(dependencies, options.json === true, code, errorMessage(error));
+            return;
+        }
+        const output = failureOutput(4, "INTERNAL_ERROR", errorMessage(error));
+        if (options.json === true) {
+            writeJson(dependencies.stdout, output);
+        }
+        else {
+            writeLine(dependencies.stderr, output.failure.message);
+        }
+        dependencies.setExitCode(4);
+    }
+}
+export { CONFIG_PATH, writeFailure };

package/dist/cli/main.d.ts

@@ -5,4 +5,4 @@ export interface TerminationSignalSource {
     off: (event: "SIGINT" | "SIGTERM", listener: () => void) => unknown;
 }
 export declare function withTerminationSignal<T>(operation: (signal: AbortSignal) => Promise<T>, source?: TerminationSignalSource): Promise<T>;
-export declare function runMain(argv: readonly string[], dependencies?: CliDependencies): Promise<void>;
+export declare function runMain(argv: readonly string[], baseDependencies?: CliDependencies): Promise<void>;

package/dist/cli/main.js

@@ -1,9 +1,12 @@
 #!/usr/bin/env node
 import { realpathSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { CommanderError } from "commander";
 import { createProductionDependencies } from "./dependencies.js";
+import { RuntimeBackendConfigError, RuntimeBackendSelectionError, resolveRuntimeBackendChoiceFromInvocation } from "./runtime-selection.js";
+import { commandEvent, describeInvocation } from "./diagnostics-recorder.js";
 import { errorMessage, failureOutput, writeJson, writeLine } from "./output.js";
 import { createProgram } from "./program.js";
 export async function withTerminationSignal(operation, source = process) {
@@ -41,11 +44,64 @@ function overrideCommandExits(command) {
         overrideCommandExits(child);
     }
 }
-export async function runMain(argv, dependencies = createProductionDependencies()) {
+/**
+ * Wraps the dependencies so the finished invocation can be journaled: the
+ * last exit code, and stdout only when the command promised one JSON value.
+ */
+function observeInvocation(dependencies, json) {
+    let exitCode = 0;
+    let stdout = "";
+    return {
+        dependencies: {
+            ...dependencies,
+            stdout: {
+                write: (content) => {
+                    if (json)
+                        stdout += content;
+                    dependencies.stdout.write(content);
+                }
+            },
+            setExitCode: (code) => {
+                exitCode = code;
+                dependencies.setExitCode(code);
+            }
+        },
+        exitCode: () => exitCode,
+        stdout: () => (json ? stdout : undefined)
+    };
+}
+async function journalInvocation(dependencies, invocation, startedAt, observed) {
+    const diagnostics = dependencies.diagnostics;
+    if (diagnostics === undefined || invocation === undefined)
+        return;
+    try {
+        await diagnostics.journal.append(invocation.projectRoot, commandEvent({
+            invocation,
+            startedAt,
+            durationMs: Date.now() - startedAt.getTime(),
+            exitCode: observed.exitCode(),
+            stdout: observed.stdout(),
+            telemetry: diagnostics.telemetry
+        }));
+    }
+    catch {
+        // The journal is best-effort evidence; it never changes a command result.
+    }
+}
+export async function runMain(argv, baseDependencies = createProductionDependencies()) {
     const json = argv.includes("--json");
+    const startedAt = new Date();
+    const observed = observeInvocation(baseDependencies, json);
+    const dependencies = baseDependencies.diagnostics === undefined
+        ? baseDependencies
+        : observed.dependencies;
+    let invocation;
     try {
         const program = createProgram(dependencies);
         overrideCommandExits(program);
+        program.hook("preAction", (_program, action) => {
+            invocation = describeInvocation(action, dependencies.cwd());
+        });
         await program.parseAsync([...argv]);
     }
     catch (error) {
@@ -65,9 +121,58 @@ export async function runMain(argv, dependencies = createProductionDependencies(
         }
         dependencies.setExitCode(exitCode);
     }
+    finally {
+        await journalInvocation(dependencies, invocation, startedAt, observed);
+    }
 }
 const entryPath = process.argv[1];
 if (entryPath !== undefined
     && import.meta.url === pathToFileURL(realpathSync(resolve(entryPath))).href) {
-    await withTerminationSignal((signal) => runMain(process.argv, createProductionDependencies(signal)));
+    await withTerminationSignal(async (signal) => {
+        let dependencies;
+        try {
+            dependencies = createProductionDependencies(signal, {
+                runtimeBackendChoice: await resolveRuntimeBackendChoiceFromInvocation({
+                    env: process.env,
+                    argv: process.argv,
+                    cwd: process.cwd(),
+                    readConfigFile: (path) => readFile(path, "utf8")
+                })
+            });
+        }
+        catch (error) {
+            if (error instanceof RuntimeBackendSelectionError
+                || error instanceof RuntimeBackendConfigError) {
+                const output = failureOutput(2, "CONFIG_INVALID", error.message);
+                if (process.argv.includes("--json")) {
+                    writeJson({
+                        write: (content) => {
+                            process.stdout.write(content);
+                        }
+                    }, output);
+                }
+                else {
+                    writeLine({
+                        write: (content) => {
+                            process.stderr.write(content);
+                        }
+                    }, output.failure.message);
+                }
+                process.exitCode = 2;
+                return;
+            }
+            throw error;
+        }
+        try {
+            await runMain(process.argv, dependencies);
+        }
+        finally {
+            try {
+                await dependencies.close?.();
+            }
+            catch (error) {
+                process.stderr.write(`TapHound: failed to release the runtime backend: ${errorMessage(error)}\n`);
+            }
+        }
+    });
 }

package/dist/cli/output.d.ts

@@ -1,9 +1,10 @@
 import type { DoctorReport } from "../application/doctor/doctor-service.js";
-import type { FailureCode } from "../domain/failure.js";
+import type { ContextLoadError } from "../application/context/context-loader.js";
+import type { FailureCode, TapHoundExitCode } from "../domain/failure.js";
 import type { TextOutput } from "./dependencies.js";
 export interface CliFailureOutput {
     status: "error";
-    exitCode: 2 | 3 | 4;
+    exitCode: TapHoundExitCode;
     failure: {
         code: FailureCode;
         message: string;
@@ -11,6 +12,7 @@ export interface CliFailureOutput {
 }
 export declare function writeJson(output: TextOutput, value: unknown): void;
 export declare function writeLine(output: TextOutput, value: string): void;
-export declare function failureOutput(exitCode: 2 | 3 | 4, code: FailureCode, message: string): CliFailureOutput;
+export declare function failureOutput(exitCode: TapHoundExitCode, code: FailureCode, message: string): CliFailureOutput;
 export declare function doctorMessage(report: DoctorReport): string;
 export declare function errorMessage(error: unknown): string;
+export declare function contextLoadHint(error: ContextLoadError): string | undefined;

package/dist/cli/output.js

@@ -20,3 +20,15 @@ export function doctorMessage(report) {
 export function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+export function contextLoadHint(error) {
+    if (error.code !== "CONTEXT_INVALID"
+        || (!error.message.includes("index does not exist")
+            && !error.message.includes("shard does not exist"))) {
+        return undefined;
+    }
+    return "Project Context is missing at the resolved path. Generate the "
+        + "committed Context first with `taphound context generate`, or pass "
+        + "--context with an explicit index path. For a registered local "
+        + "target, run `taphound local sync <id>` before retrying. See "
+        + "docs/agent-integration.md and docs/local-target.md.";
+}

package/dist/cli/program.js

@@ -1,11 +1,21 @@
 import { Command } from "commander";
+import { readCliVersion } from "./version.js";
 import { createContextCommand } from "./commands/context.js";
 import { createDoctorCommand } from "./commands/doctor.js";
 import { createGenerationCommand } from "./commands/generation.js";
 import { createInitCommand } from "./commands/init.js";
+import { createJourneyCommand } from "./commands/journey.js";
+import { createObserveCommand } from "./commands/observe.js";
 import { createProjectCommand } from "./commands/project.js";
 import { createRecordCommand } from "./commands/record.js";
 import { createVerifyCommand } from "./commands/verify.js";
+import { createContractCommand } from "./commands/contract.js";
+import { createAlignCommand } from "./commands/align.js";
+import { createImpactCommand } from "./commands/impact.js";
+import { createKnowledgeCommand } from "./commands/knowledge.js";
+import { createBaselineCommand } from "./commands/baseline.js";
+import { createFailureCommand } from "./commands/failure.js";
+import { createDiagnoseCommand } from "./commands/diagnose.js";
 import { createProductionDependencies } from "./dependencies.js";
 export function createProgram(dependencies = createProductionDependencies()) {
     const configureOutput = (command) => {
@@ -25,6 +35,7 @@ export function createProgram(dependencies = createProductionDependencies()) {
     return new Command()
         .name("taphound")
         .description("Deterministic app journey recording and verification")
+        .version(readCliVersion(), "-v, --version")
         .configureOutput({
         writeOut: (content) => {
             dependencies.stdout.write(content);
@@ -36,8 +47,17 @@ export function createProgram(dependencies = createProductionDependencies()) {
         .addCommand(configureOutput(createDoctorCommand(dependencies)))
         .addCommand(configureOutput(createRecordCommand(dependencies)))
         .addCommand(configureOutput(createVerifyCommand(dependencies)))
+        .addCommand(configureOutput(createContractCommand(dependencies)))
+        .addCommand(configureOutput(createObserveCommand(dependencies)))
         .addCommand(configureOutput(createProjectCommand(dependencies)))
         .addCommand(configureOutput(createContextCommand(dependencies)))
+        .addCommand(configureOutput(createJourneyCommand(dependencies)))
         .addCommand(configureOutput(createGenerationCommand(dependencies)))
-        .addCommand(configureOutput(createInitCommand(dependencies)));
+        .addCommand(configureOutput(createKnowledgeCommand(dependencies)))
+        .addCommand(configureOutput(createBaselineCommand(dependencies)))
+        .addCommand(configureOutput(createFailureCommand(dependencies)))
+        .addCommand(configureOutput(createInitCommand(dependencies)))
+        .addCommand(configureOutput(createAlignCommand(dependencies)))
+        .addCommand(configureOutput(createImpactCommand(dependencies)))
+        .addCommand(configureOutput(createDiagnoseCommand(dependencies)));
 }

package/dist/cli/project-root.d.ts

@@ -0,0 +1 @@
+export declare function canonicalProjectRoot(cwd: string, projectRoot: string): Promise<string>;

package/dist/cli/project-root.js

@@ -0,0 +1,6 @@
+import { realpath } from "node:fs/promises";
+import { resolve } from "node:path";
+export async function canonicalProjectRoot(cwd, projectRoot) {
+    const absolute = resolve(cwd, projectRoot);
+    return realpath(absolute).catch(() => absolute);
+}

package/dist/cli/runtime-selection.d.ts

@@ -0,0 +1,22 @@
+import { type RuntimeBackendChoice } from "../domain/runtime.js";
+export declare const RUNTIME_BACKEND_ENV_VAR = "TAPHOUND_RUNTIME_BACKEND";
+export declare class RuntimeBackendSelectionError extends Error {
+    constructor(value: string);
+}
+export declare class RuntimeBackendConfigError extends Error {
+    constructor(path: string, value: unknown);
+}
+export declare function readRuntimeBackendChoice(env: Record<string, string | undefined>): RuntimeBackendChoice;
+export interface RuntimeBackendInvocation {
+    env: Record<string, string | undefined>;
+    argv: readonly string[];
+    cwd: string;
+    readConfigFile: (path: string) => Promise<string>;
+}
+/**
+ * Resolves the effective runtime backend choice for one CLI invocation.
+ * An explicit `TAPHOUND_RUNTIME_BACKEND` wins over the config file so CI and
+ * experiments can override committed project state; `auto` defers to the
+ * config's `runtime.backend`, which itself defaults to `auto`.
+ */
+export declare function resolveRuntimeBackendChoiceFromInvocation(invocation: RuntimeBackendInvocation): Promise<RuntimeBackendChoice>;