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

package/dist/cli/runtime-selection.js

@@ -0,0 +1,92 @@
+import { resolve } from "node:path";
+import { RuntimeBackendChoiceSchema } from "../domain/runtime.js";
+import { CONFIG_PATH } from "../domain/workspace.js";
+export const RUNTIME_BACKEND_ENV_VAR = "TAPHOUND_RUNTIME_BACKEND";
+export class RuntimeBackendSelectionError extends Error {
+    constructor(value) {
+        super(`${RUNTIME_BACKEND_ENV_VAR} must be one of ${RuntimeBackendChoiceSchema.options
+            .map((option) => `"${option}"`)
+            .join(", ")}, received "${value}"`);
+        this.name = "RuntimeBackendSelectionError";
+    }
+}
+export class RuntimeBackendConfigError extends Error {
+    constructor(path, value) {
+        super(`runtime.backend in ${path} must be one of ${RuntimeBackendChoiceSchema.options
+            .map((option) => `"${option}"`)
+            .join(", ")}, received ${typeof value === "string" ? `"${value}"` : String(value)}`);
+        this.name = "RuntimeBackendConfigError";
+    }
+}
+export function readRuntimeBackendChoice(env) {
+    const raw = env[RUNTIME_BACKEND_ENV_VAR];
+    if (raw === undefined || raw.trim() === "") {
+        return "auto";
+    }
+    const value = raw.trim();
+    const parsed = RuntimeBackendChoiceSchema.safeParse(value);
+    if (!parsed.success) {
+        throw new RuntimeBackendSelectionError(value);
+    }
+    return parsed.data;
+}
+function argvOptionValue(argv, name) {
+    const prefix = `--${name}=`;
+    let value;
+    for (let index = 0; index < argv.length; index += 1) {
+        const argument = argv[index];
+        if (argument === undefined) {
+            continue;
+        }
+        if (argument === `--${name}` && argv[index + 1] !== undefined) {
+            value = argv[index + 1] ?? undefined;
+        }
+        else if (argument.startsWith(prefix)) {
+            value = argument.slice(prefix.length);
+        }
+    }
+    return value;
+}
+async function configBackendChoice(invocation) {
+    const project = argvOptionValue(invocation.argv, "project")
+        ?? invocation.cwd;
+    const configPath = resolve(project, argvOptionValue(invocation.argv, "config") ?? CONFIG_PATH);
+    let text;
+    try {
+        text = await invocation.readConfigFile(configPath);
+    }
+    catch {
+        return "auto";
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return "auto";
+    }
+    const backend = parsed === null || typeof parsed !== "object"
+        ? undefined
+        : parsed.runtime?.backend;
+    if (backend === undefined) {
+        return "auto";
+    }
+    const choice = RuntimeBackendChoiceSchema.safeParse(backend);
+    if (!choice.success) {
+        throw new RuntimeBackendConfigError(configPath, backend);
+    }
+    return choice.data;
+}
+/**
+ * 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 async function resolveRuntimeBackendChoiceFromInvocation(invocation) {
+    const fromEnv = readRuntimeBackendChoice(invocation.env);
+    if (fromEnv !== "auto") {
+        return fromEnv;
+    }
+    return configBackendChoice(invocation);
+}

package/dist/cli/version.d.ts

@@ -0,0 +1 @@
+export declare function readCliVersion(): string;

package/dist/cli/version.js

@@ -0,0 +1,14 @@
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+export function readCliVersion() {
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        const pkgPath = resolve(here, "../../package.json");
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        return pkg.version ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}

package/dist/cli/workspace-guard.d.ts

@@ -0,0 +1,2 @@
+import type { CliDependencies } from "./dependencies.js";
+export declare function prepareWorkspace(dependencies: Pick<CliDependencies, "workspaceLayout">, projectRoot: string): Promise<void>;

package/dist/cli/workspace-guard.js

@@ -0,0 +1,3 @@
+export async function prepareWorkspace(dependencies, projectRoot) {
+    await dependencies.workspaceLayout.ensureBuildLayout(projectRoot);
+}

package/dist/domain/binding-reference.d.ts

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export declare const BINDING_REFERENCE: RegExp;
+export declare function bindingName(value: string): string | undefined;
+export declare function checkBindingReferences(value: unknown, context: z.RefinementCtx, allowed: readonly (readonly (string | number)[])[], path?: (string | number)[]): void;

package/dist/domain/binding-reference.js

@@ -0,0 +1,23 @@
+export const BINDING_REFERENCE = /^\$\{([a-z][a-zA-Z0-9_]{0,31})\}$/;
+export function bindingName(value) {
+    return BINDING_REFERENCE.exec(value)?.[1];
+}
+export function checkBindingReferences(value, context, allowed, path = []) {
+    if (typeof value === "string") {
+        if (value.includes("${") && (bindingName(value) === undefined
+            || !allowed.some((candidate) => (candidate.length === path.length
+                && candidate.every((item, index) => item === path[index]))))) {
+            context.addIssue({
+                code: "custom",
+                path,
+                message: "Binding references are permitted only as exact values in approved fields"
+            });
+        }
+        return;
+    }
+    if (value === null || typeof value !== "object")
+        return;
+    for (const [key, item] of Object.entries(value)) {
+        checkBindingReferences(item, context, allowed, [...path, ...(Array.isArray(value) ? [Number(key)] : [key])]);
+    }
+}

package/dist/domain/checkpoint.d.ts

@@ -0,0 +1,404 @@
+import { z } from "zod";
+/**
+ * Checkpoint: a named behavioral expectation at a point in a Journey.
+ *
+ * A Checkpoint is not a screenshot. It is a verifiable contract over
+ * observable behavior: which Activity is in the foreground, which elements
+ * are present/absent, and (optionally) a Knowledge Screen. The expectation is
+ * deterministic and machine-checkable; a checkpoint never triggers an AI
+ * layer by itself (see docs/source-of-truth.md).
+ */
+export declare const CheckpointAllOfConditionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"activity">;
+    expected: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"screen">;
+    expected: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"visibleElement">;
+    locator: z.ZodType<import("./layout.js").Locator, unknown, z.core.$ZodTypeInternals<import("./layout.js").Locator, unknown>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"absentElement">;
+    locator: z.ZodType<import("./layout.js").Locator, unknown, z.core.$ZodTypeInternals<import("./layout.js").Locator, unknown>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"logcatEvent">;
+    expect: z.ZodObject<{
+        type: z.ZodLiteral<"logcatEvent">;
+        window: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            from: z.ZodLiteral<"stepStart">;
+        }, z.core.$strict>, z.ZodObject<{
+            from: z.ZodLiteral<"runStart">;
+        }, z.core.$strict>, z.ZodObject<{
+            from: z.ZodLiteral<"marker">;
+            markerId: z.ZodString;
+        }, z.core.$strict>], "from">>;
+        tag: z.ZodString;
+        capture: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            field: z.ZodOptional<z.ZodString>;
+            group: z.ZodOptional<z.ZodLiteral<"correlation">>;
+            valueType: z.ZodEnum<{
+                string: "string";
+                integer: "integer";
+                identifier: "identifier";
+            }>;
+        }, z.core.$strict>>;
+        correlation: z.ZodOptional<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodString]>;
+        }, z.core.$strict>>;
+        event: z.ZodString;
+        fields: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        unique: z.ZodDefault<z.ZodLiteral<true>>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "kind">;
+export declare const CheckpointExpectSchema: z.ZodObject<{
+    allOf: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"activity">;
+        expected: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"screen">;
+        expected: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"visibleElement">;
+        locator: z.ZodType<import("./layout.js").Locator, unknown, z.core.$ZodTypeInternals<import("./layout.js").Locator, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"absentElement">;
+        locator: z.ZodType<import("./layout.js").Locator, unknown, z.core.$ZodTypeInternals<import("./layout.js").Locator, unknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"logcatEvent">;
+        expect: z.ZodObject<{
+            type: z.ZodLiteral<"logcatEvent">;
+            window: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                from: z.ZodLiteral<"stepStart">;
+            }, z.core.$strict>, z.ZodObject<{
+                from: z.ZodLiteral<"runStart">;
+            }, z.core.$strict>, z.ZodObject<{
+                from: z.ZodLiteral<"marker">;
+                markerId: z.ZodString;
+            }, z.core.$strict>], "from">>;
+            tag: z.ZodString;
+            capture: z.ZodOptional<z.ZodObject<{
+                name: z.ZodString;
+                field: z.ZodOptional<z.ZodString>;
+                group: z.ZodOptional<z.ZodLiteral<"correlation">>;
+                valueType: z.ZodEnum<{
+                    string: "string";
+                    integer: "integer";
+                    identifier: "identifier";
+                }>;
+            }, z.core.$strict>>;
+            correlation: z.ZodOptional<z.ZodObject<{
+                key: z.ZodString;
+                value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodString]>;
+            }, z.core.$strict>>;
+            event: z.ZodString;
+            fields: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            unique: z.ZodDefault<z.ZodLiteral<true>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>], "kind">>;
+    timeoutMs: z.ZodNumber;
+}, z.core.$strict>;
+export declare const CheckpointDefinitionSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    id: z.ZodString;
+    name: z.ZodString;
+    stepIndex: z.ZodOptional<z.ZodNumber>;
+    expect: z.ZodObject<{
+        allOf: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"activity">;
+            expected: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"screen">;
+            expected: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"visibleElement">;
+            locator: z.ZodType<import("./layout.js").Locator, unknown, z.core.$ZodTypeInternals<import("./layout.js").Locator, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"absentElement">;
+            locator: z.ZodType<import("./layout.js").Locator, unknown, z.core.$ZodTypeInternals<import("./layout.js").Locator, unknown>>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"logcatEvent">;
+            expect: z.ZodObject<{
+                type: z.ZodLiteral<"logcatEvent">;
+                window: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    from: z.ZodLiteral<"stepStart">;
+                }, z.core.$strict>, z.ZodObject<{
+                    from: z.ZodLiteral<"runStart">;
+                }, z.core.$strict>, z.ZodObject<{
+                    from: z.ZodLiteral<"marker">;
+                    markerId: z.ZodString;
+                }, z.core.$strict>], "from">>;
+                tag: z.ZodString;
+                capture: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    field: z.ZodOptional<z.ZodString>;
+                    group: z.ZodOptional<z.ZodLiteral<"correlation">>;
+                    valueType: z.ZodEnum<{
+                        string: "string";
+                        integer: "integer";
+                        identifier: "identifier";
+                    }>;
+                }, z.core.$strict>>;
+                correlation: z.ZodOptional<z.ZodObject<{
+                    key: z.ZodString;
+                    value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodString]>;
+                }, z.core.$strict>>;
+                event: z.ZodString;
+                fields: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+                unique: z.ZodDefault<z.ZodLiteral<true>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>], "kind">>;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strict>;
+    status: z.ZodDefault<z.ZodEnum<{
+        observed: "observed";
+        inferred: "inferred";
+        verified: "verified";
+    }>>;
+}, z.core.$strict>;
+export declare const BaselineElementFactSchema: z.ZodObject<{
+    locator: z.ZodOptional<z.ZodType<import("./layout.js").Locator, unknown, z.core.$ZodTypeInternals<import("./layout.js").Locator, unknown>>>;
+    anchorId: z.ZodOptional<z.ZodString>;
+    stepIndex: z.ZodNumber;
+    kind: z.ZodLiteral<"present">;
+    matchedBy: z.ZodOptional<z.ZodEnum<{
+        anchor: "anchor";
+        resourceId: "resourceId";
+        text: "text";
+        contentDescription: "contentDescription";
+    }>>;
+    fallbackUsed: z.ZodOptional<z.ZodBoolean>;
+    evidenceSha256: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const BaselineActivityFactSchema: z.ZodObject<{
+    stepIndex: z.ZodNumber;
+    before: z.ZodString;
+    after: z.ZodString;
+}, z.core.$strict>;
+export declare const BaselineScreenFactSchema: z.ZodObject<{
+    screen: z.ZodString;
+    status: z.ZodEnum<{
+        ambiguous: "ambiguous";
+        matched: "matched";
+        unresolved: "unresolved";
+    }>;
+}, z.core.$strict>;
+export declare const BaselineCheckpointFactSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"activity">;
+    expected: z.ZodString;
+    checkpointId: z.ZodString;
+    stepIndex: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"screen">;
+    expected: z.ZodString;
+    checkpointId: z.ZodString;
+    stepIndex: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"visibleElement">;
+    locator: z.ZodType<import("./layout.js").Locator, unknown, z.core.$ZodTypeInternals<import("./layout.js").Locator, unknown>>;
+    checkpointId: z.ZodString;
+    stepIndex: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"absentElement">;
+    locator: z.ZodType<import("./layout.js").Locator, unknown, z.core.$ZodTypeInternals<import("./layout.js").Locator, unknown>>;
+    checkpointId: z.ZodString;
+    stepIndex: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"logcatEvent">;
+    expect: z.ZodObject<{
+        type: z.ZodLiteral<"logcatEvent">;
+        window: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            from: z.ZodLiteral<"stepStart">;
+        }, z.core.$strict>, z.ZodObject<{
+            from: z.ZodLiteral<"runStart">;
+        }, z.core.$strict>, z.ZodObject<{
+            from: z.ZodLiteral<"marker">;
+            markerId: z.ZodString;
+        }, z.core.$strict>], "from">>;
+        tag: z.ZodString;
+        capture: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            field: z.ZodOptional<z.ZodString>;
+            group: z.ZodOptional<z.ZodLiteral<"correlation">>;
+            valueType: z.ZodEnum<{
+                string: "string";
+                integer: "integer";
+                identifier: "identifier";
+            }>;
+        }, z.core.$strict>>;
+        correlation: z.ZodOptional<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodString]>;
+        }, z.core.$strict>>;
+        event: z.ZodString;
+        fields: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+        unique: z.ZodDefault<z.ZodLiteral<true>>;
+    }, z.core.$strict>;
+    checkpointId: z.ZodString;
+    stepIndex: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>], "kind">;
+/**
+ * Baseline: frozen, hash-bound evidence of one known-good run.
+ *
+ * The Baseline is behavior evidence, not a screenshot (architecture doc
+ * §15): activity sequence, element presence facts, optional Knowledge screen
+ * detection, and the failing evidence summary fields. Every fact is
+ * deterministic and comparable.
+ */
+export declare const BaselineSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    id: z.ZodString;
+    journeySha256: z.ZodString;
+    contractSha256: z.ZodOptional<z.ZodString>;
+    capturedAt: z.ZodISODateTime;
+    packageName: z.ZodString;
+    runId: z.ZodString;
+    activities: z.ZodArray<z.ZodObject<{
+        stepIndex: z.ZodNumber;
+        before: z.ZodString;
+        after: z.ZodString;
+    }, z.core.$strict>>;
+    elements: z.ZodArray<z.ZodObject<{
+        locator: z.ZodOptional<z.ZodType<import("./layout.js").Locator, unknown, z.core.$ZodTypeInternals<import("./layout.js").Locator, unknown>>>;
+        anchorId: z.ZodOptional<z.ZodString>;
+        stepIndex: z.ZodNumber;
+        kind: z.ZodLiteral<"present">;
+        matchedBy: z.ZodOptional<z.ZodEnum<{
+            anchor: "anchor";
+            resourceId: "resourceId";
+            text: "text";
+            contentDescription: "contentDescription";
+        }>>;
+        fallbackUsed: z.ZodOptional<z.ZodBoolean>;
+        evidenceSha256: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    screens: z.ZodArray<z.ZodObject<{
+        screen: z.ZodString;
+        status: z.ZodEnum<{
+            ambiguous: "ambiguous";
+            matched: "matched";
+            unresolved: "unresolved";
+        }>;
+    }, z.core.$strict>>;
+    checkpoints: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"activity">;
+        expected: z.ZodString;
+        checkpointId: z.ZodString;
+        stepIndex: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"screen">;
+        expected: z.ZodString;
+        checkpointId: z.ZodString;
+        stepIndex: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"visibleElement">;
+        locator: z.ZodType<import("./layout.js").Locator, unknown, z.core.$ZodTypeInternals<import("./layout.js").Locator, unknown>>;
+        checkpointId: z.ZodString;
+        stepIndex: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"absentElement">;
+        locator: z.ZodType<import("./layout.js").Locator, unknown, z.core.$ZodTypeInternals<import("./layout.js").Locator, unknown>>;
+        checkpointId: z.ZodString;
+        stepIndex: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"logcatEvent">;
+        expect: z.ZodObject<{
+            type: z.ZodLiteral<"logcatEvent">;
+            window: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                from: z.ZodLiteral<"stepStart">;
+            }, z.core.$strict>, z.ZodObject<{
+                from: z.ZodLiteral<"runStart">;
+            }, z.core.$strict>, z.ZodObject<{
+                from: z.ZodLiteral<"marker">;
+                markerId: z.ZodString;
+            }, z.core.$strict>], "from">>;
+            tag: z.ZodString;
+            capture: z.ZodOptional<z.ZodObject<{
+                name: z.ZodString;
+                field: z.ZodOptional<z.ZodString>;
+                group: z.ZodOptional<z.ZodLiteral<"correlation">>;
+                valueType: z.ZodEnum<{
+                    string: "string";
+                    integer: "integer";
+                    identifier: "identifier";
+                }>;
+            }, z.core.$strict>>;
+            correlation: z.ZodOptional<z.ZodObject<{
+                key: z.ZodString;
+                value: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>, z.ZodString]>;
+            }, z.core.$strict>>;
+            event: z.ZodString;
+            fields: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
+            unique: z.ZodDefault<z.ZodLiteral<true>>;
+        }, z.core.$strict>;
+        checkpointId: z.ZodString;
+        stepIndex: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>], "kind">>>;
+    requiredEvidence: z.ZodObject<{
+        screens: z.ZodBoolean;
+    }, z.core.$strict>;
+    sourceReportPath: z.ZodString;
+}, z.core.$strict>;
+export declare function baselineEvidence(baseline: Baseline): BaselineEvidence;
+export interface BaselineEvidence {
+    activities: Baseline["activities"];
+    elements: Baseline["elements"];
+    screens: Baseline["screens"];
+    checkpoints?: Baseline["checkpoints"];
+}
+export type CheckpointExpect = z.infer<typeof CheckpointExpectSchema>;
+export type CheckpointAllOfCondition = z.infer<typeof CheckpointAllOfConditionSchema>;
+export type CheckpointDefinition = z.infer<typeof CheckpointDefinitionSchema>;
+export type BaselineElementFact = z.infer<typeof BaselineElementFactSchema>;
+export type BaselineActivityFact = z.infer<typeof BaselineActivityFactSchema>;
+export type BaselineScreenFact = z.infer<typeof BaselineScreenFactSchema>;
+export type BaselineCheckpointFact = z.infer<typeof BaselineCheckpointFactSchema>;
+export type Baseline = z.infer<typeof BaselineSchema>;
+/**
+ * Regression compare result. `regressions` is empty when current evidence is
+ * equivalent to the baseline; each entry names one drifted fact.
+ */
+export declare const RegressionDiffSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        activity: "activity";
+        screen: "screen";
+        element: "element";
+        logcatEvent: "logcatEvent";
+    }>;
+    stepIndex: z.ZodOptional<z.ZodNumber>;
+    locator: z.ZodOptional<z.ZodType<import("./layout.js").Locator, unknown, z.core.$ZodTypeInternals<import("./layout.js").Locator, unknown>>>;
+    screen: z.ZodOptional<z.ZodString>;
+    checkpointId: z.ZodOptional<z.ZodString>;
+    expected: z.ZodString;
+    actual: z.ZodString;
+}, z.core.$strict>;
+export declare const RegressionCompareResultSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    baselineId: z.ZodString;
+    journeySha256: z.ZodString;
+    comparedAt: z.ZodISODateTime;
+    equivalent: z.ZodBoolean;
+    coverage: z.ZodObject<{
+        activities: z.ZodNumber;
+        elements: z.ZodNumber;
+        screens: z.ZodNumber;
+        checkpoints: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    regressions: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            activity: "activity";
+            screen: "screen";
+            element: "element";
+            logcatEvent: "logcatEvent";
+        }>;
+        stepIndex: z.ZodOptional<z.ZodNumber>;
+        locator: z.ZodOptional<z.ZodType<import("./layout.js").Locator, unknown, z.core.$ZodTypeInternals<import("./layout.js").Locator, unknown>>>;
+        screen: z.ZodOptional<z.ZodString>;
+        checkpointId: z.ZodOptional<z.ZodString>;
+        expected: z.ZodString;
+        actual: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type RegressionDiff = z.infer<typeof RegressionDiffSchema>;
+export type RegressionCompareResult = z.infer<typeof RegressionCompareResultSchema>;