@interf/compiler 0.5.1 → 0.6.3

package/dist/packages/project-model/source-config.js

@@ -0,0 +1,297 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join, relative, resolve, sep } from "node:path";
+import { readInterfConfig, refreshCompiledBootstrapGuidance, } from "./interf.js";
+import { seedCompiledWorkflowPackage } from "../workflow-package/interf-workflow-package.js";
+import { readJsonFileWithSchema } from "../../lib/parse.js";
+import { getCompiledWorkflow } from "../workflow-package/workflow-definitions.js";
+import { SourceFolderConfigSchema, } from "./lib/schema.js";
+import { slugify } from "../../lib/util.js";
+import { assertPathWithinRoot } from "../../lib/util.js";
+import { defaultControlPathForCompiled, resolveSourceControlPathForCompiled, compiledInterfConfigPath, compiledInterfRoot, } from "./compiled-paths.js";
+export const SOURCE_FOLDER_CONFIG_FILE = "interf.json";
+function sourceConfigPath(sourcePath) {
+    return join(sourcePath, SOURCE_FOLDER_CONFIG_FILE);
+}
+function normalizeTruthChecks(cases) {
+    const seen = new Set();
+    return cases.map((caseSpec, index) => {
+        const baseId = slugify(caseSpec.id ?? caseSpec.question) || `check-${index + 1}`;
+        let id = baseId;
+        let suffix = 2;
+        while (seen.has(id)) {
+            id = `${baseId}-${suffix}`;
+            suffix += 1;
+        }
+        seen.add(id);
+        return {
+            id,
+            question: caseSpec.question.trim(),
+            ...(caseSpec.answer ? { answer: caseSpec.answer.trim() } : {}),
+            ...(caseSpec.strictness ? { strictness: caseSpec.strictness.trim() } : {}),
+            ...(caseSpec.expect ? { expect: caseSpec.expect } : {}),
+        };
+    });
+}
+export function fingerprintTruthChecks(checks) {
+    const normalized = checks.map((check) => ({
+        question: check.question.trim(),
+        ...(check.answer ? { answer: check.answer.trim() } : {}),
+        ...(check.strictness ? { strictness: check.strictness.trim() } : {}),
+        ...(check.expect ? { expect: check.expect } : {}),
+    }));
+    return createHash("sha256")
+        .update(JSON.stringify(normalized))
+        .digest("hex")
+        .slice(0, 16);
+}
+export function loadSourceFolderConfig(sourcePath) {
+    const filePath = sourceConfigPath(sourcePath);
+    if (!existsSync(filePath))
+        return null;
+    return readJsonFileWithSchema(filePath, "Interf project config", SourceFolderConfigSchema);
+}
+export function listSourceDatasetConfigs(config) {
+    return config?.datasets ?? [];
+}
+export function resolveDatasetCompileMaxAttempts(datasetConfig, override = null) {
+    const configured = override ?? datasetConfig.max_attempts ?? null;
+    if (configured == null)
+        return null;
+    const normalized = Math.trunc(configured);
+    if (!Number.isFinite(normalized) || normalized < 1)
+        return 1;
+    return Math.min(5, normalized);
+}
+export function resolveDatasetCompileMaxLoops(datasetConfig, override = null) {
+    const configured = override ?? datasetConfig.max_loops ?? null;
+    if (configured == null)
+        return null;
+    const normalized = Math.trunc(configured);
+    if (!Number.isFinite(normalized) || normalized < 1)
+        return 1;
+    return Math.min(3, normalized);
+}
+export function getDefaultSourceDatasetConfig(config) {
+    const datasets = listSourceDatasetConfigs(config);
+    return datasets[0] ?? null;
+}
+export function findSourceDatasetConfig(config, datasetName) {
+    return listSourceDatasetConfigs(config).find((dataset) => dataset.name === datasetName) ?? null;
+}
+function toWritableSourceProjectConfig(config) {
+    const datasets = config?.datasets ?? [];
+    if (datasets.length > 0) {
+        return {
+            datasets: datasets.map((dataset) => toWritableSourceDatasetConfig(dataset)),
+        };
+    }
+    return {};
+}
+function toWritableSourceDatasetConfig(dataset) {
+    return {
+        name: dataset.name,
+        path: dataset.path,
+        ...(dataset.about ? { about: dataset.about } : {}),
+        ...(dataset.workflow && dataset.workflow !== "interf" ? { workflow: dataset.workflow } : {}),
+        ...(typeof dataset.max_attempts === "number" ? { max_attempts: dataset.max_attempts } : {}),
+        ...(typeof dataset.max_loops === "number" ? { max_loops: dataset.max_loops } : {}),
+        checks: dataset.checks,
+    };
+}
+export function saveSourceFolderConfig(sourcePath, config) {
+    writeFileSync(sourceConfigPath(sourcePath), JSON.stringify(toWritableSourceProjectConfig(config), null, 2) + "\n");
+}
+export function appendSourceDatasetChecks(sourcePath, datasetName, checks) {
+    const existing = loadSourceFolderConfig(sourcePath);
+    const currentDataset = findSourceDatasetConfig(existing, datasetName);
+    const otherDatasets = listSourceDatasetConfigs(existing).filter((dataset) => dataset.name !== datasetName);
+    const currentChecks = currentDataset?.checks ?? [];
+    const nextDataset = {
+        ...toWritableSourceDatasetConfig(currentDataset ?? {
+            name: datasetName,
+            path: `./${datasetName}`,
+            checks: [],
+        }),
+        checks: [...currentChecks, ...checks],
+    };
+    saveSourceFolderConfig(sourcePath, {
+        datasets: [
+            nextDataset,
+            ...otherDatasets,
+        ],
+    });
+}
+export function upsertSourceDatasetConfig(sourcePath, datasetConfig, options = {}) {
+    const existing = loadSourceFolderConfig(sourcePath);
+    const datasets = listSourceDatasetConfigs(existing);
+    const candidateNames = Array.from(new Set([datasetConfig.name, options.matchName].filter((value) => Boolean(value))));
+    const existingIndex = datasets.findIndex((entry) => candidateNames.includes(entry.name));
+    if (existingIndex >= 0) {
+        datasets[existingIndex] = datasetConfig;
+    }
+    else {
+        datasets.push(datasetConfig);
+    }
+    saveSourceFolderConfig(sourcePath, {
+        datasets,
+    });
+}
+export function compiledMaxAttempts(maxAttempts) {
+    if (maxAttempts == null)
+        return undefined;
+    return resolveDatasetCompileMaxAttempts({ max_attempts: maxAttempts }, null) ?? 1;
+}
+export function compiledMaxLoops(maxLoops) {
+    if (maxLoops == null)
+        return undefined;
+    return resolveDatasetCompileMaxLoops({ max_loops: maxLoops }, null) ?? 1;
+}
+export function sourceDatasetConfigFromInterfConfig(config, datasetPath = `./${config.name}`) {
+    return {
+        name: config.name,
+        path: datasetPath,
+        ...(config.about ? { about: config.about } : {}),
+        ...(config.workflow ? { workflow: config.workflow } : {}),
+        ...(typeof config.max_attempts === "number"
+            ? { max_attempts: config.max_attempts }
+            : {}),
+        ...(typeof config.max_loops === "number"
+            ? { max_loops: config.max_loops }
+            : {}),
+        checks: config.checks ?? [],
+    };
+}
+export function loadCompiledDatasetConfig(compiledPath) {
+    const config = readInterfConfig(compiledPath);
+    if (!config)
+        return null;
+    const projectPath = resolveSourceControlPathForCompiled(compiledPath);
+    const configuredDatasets = listSourceDatasetConfigs(loadSourceFolderConfig(projectPath));
+    const fallbackDatasetPath = configuredDatasets.length === 1
+        ? configuredDatasets[0].path
+        : `./${config.name}`;
+    const datasetPath = typeof config.source?.dataset_path === "string" && config.source.dataset_path.length > 0
+        ? relative(projectPath, assertPathWithinRoot(projectPath, resolve(compiledPath, config.source.dataset_path), "Compiled context source path")).split(sep).join("/") || fallbackDatasetPath
+        : fallbackDatasetPath;
+    return sourceDatasetConfigFromInterfConfig(config, datasetPath);
+}
+export function saveCompiledInterfConfig(compiledPath, config) {
+    mkdirSync(compiledInterfRoot(compiledPath), { recursive: true });
+    writeFileSync(compiledInterfConfigPath(compiledPath), JSON.stringify(config, null, 2) + "\n");
+    return config;
+}
+export function syncCompiledInterfConfigFromSourceDatasetConfig(compiledPath, datasetConfig) {
+    const current = readInterfConfig(compiledPath);
+    const projectPath = resolveSourceControlPathForCompiled(compiledPath);
+    const datasetAbsolutePath = resolve(projectPath, datasetConfig.path);
+    const datasetRelativePath = relative(compiledPath, datasetAbsolutePath).split(sep).join("/") || ".";
+    const workflowId = datasetConfig.workflow ?? current?.workflow ?? "interf";
+    const workflowChanged = current?.workflow !== undefined && current.workflow !== workflowId;
+    const workflowOrigin = workflowChanged || !current?.workflow_origin
+        ? {
+            selected: workflowId,
+            local_draft: false,
+        }
+        : current.workflow_origin;
+    const { type: _ignoredType, name: _ignoredName, about: _ignoredAbout, workflow: _ignoredWorkflow, max_attempts: _ignoredMaxAttempts, max_loops: _ignoredMaxLoops, checks: _ignoredChecks, workflow_origin: _ignoredWorkflowOrigin, source: _ignoredSource, ...passthrough } = current ?? {};
+    const nextConfig = {
+        ...passthrough,
+        ...(!current ? {
+            type: "compiled",
+            source: {
+                path: "./raw",
+            },
+        } : {}),
+        type: "compiled",
+        name: datasetConfig.name,
+        ...(datasetConfig.about ? { about: datasetConfig.about } : {}),
+        workflow: workflowId,
+        ...(typeof datasetConfig.max_attempts === "number"
+            ? { max_attempts: datasetConfig.max_attempts }
+            : {}),
+        ...(typeof datasetConfig.max_loops === "number"
+            ? { max_loops: datasetConfig.max_loops }
+            : {}),
+        checks: datasetConfig.checks,
+        workflow_origin: workflowOrigin,
+        source: {
+            path: current?.source?.path ?? "./raw",
+            control_path: defaultControlPathForCompiled(compiledPath),
+            dataset_path: datasetRelativePath,
+        },
+    };
+    const saved = saveCompiledInterfConfig(compiledPath, nextConfig);
+    if (workflowChanged) {
+        const sourcePath = projectPath;
+        const selectedWorkflow = getCompiledWorkflow(workflowId, { sourcePath });
+        seedCompiledWorkflowPackage({
+            compiledPath,
+            sourcePath,
+            workflowId: selectedWorkflow.id,
+        });
+    }
+    refreshCompiledBootstrapGuidance(compiledPath);
+    return saved;
+}
+function buildLoadedTestSpec(options) {
+    if (options.checks.length === 0)
+        return null;
+    const testId = options.id ?? slugify(options.name);
+    return {
+        id: options.targetType === "raw" ? `${testId}-raw` : testId,
+        filePath: options.filePath,
+        type: options.targetType,
+        name: options.name,
+        description: options.about ?? options.fallbackDescription,
+        cases: normalizeTruthChecks(options.checks),
+    };
+}
+export function buildTestSpecFromSourceFolderConfig(options) {
+    const { sourcePath, targetName, targetType = "compiled" } = options;
+    const config = loadSourceFolderConfig(sourcePath);
+    if (!config)
+        return null;
+    const datasets = listSourceDatasetConfigs(config);
+    if (datasets.length === 0)
+        return null;
+    const match = targetName
+        ? datasets.find((entry) => entry.name === targetName)
+        : datasets.length === 1
+            ? datasets[0]
+            : getDefaultSourceDatasetConfig(config);
+    if (!match)
+        return null;
+    const configPath = sourceConfigPath(sourcePath);
+    return buildLoadedTestSpec({
+        id: match.id,
+        name: match.name,
+        about: match.about,
+        checks: match.checks,
+        targetType,
+        filePath: targetType === "raw"
+            ? `${configPath}#datasets/${match.name}:file-as-is`
+            : `${configPath}#datasets/${match.name}:compiled`,
+        fallbackDescription: `Derived from saved dataset checks in ${SOURCE_FOLDER_CONFIG_FILE}`,
+    });
+}
+export function buildTestSpecFromCompiledDatasetConfig(options) {
+    const { compiledPath, targetType = "compiled" } = options;
+    const config = readInterfConfig(compiledPath);
+    const configPath = compiledInterfConfigPath(compiledPath);
+    if (!config)
+        return null;
+    return buildLoadedTestSpec({
+        name: config.name,
+        about: config.about,
+        checks: config.checks ?? [],
+        targetType,
+        filePath: targetType === "raw"
+            ? `${configPath}#checks:file-as-is`
+            : `${configPath}#checks:compiled`,
+        fallbackDescription: "Derived from checks in the compiled context config.",
+    });
+}
+export function resolveSourceDatasetPath(projectPath, datasetConfig) {
+    return assertPathWithinRoot(projectPath, resolve(projectPath, datasetConfig.path), "Dataset path");
+}

package/dist/packages/testing/index.d.ts

@@ -0,0 +1,13 @@
+export * as schema from "./lib/schema.js";
+export * as test from "./test.js";
+export * as execution from "./test-execution.js";
+export * as matrices from "./test-matrices.js";
+export * as paths from "./test-paths.js";
+export * as profilePresets from "./test-profile-presets.js";
+export * as sandbox from "./test-sandbox.js";
+export * as specs from "./test-specs.js";
+export * as targets from "./test-targets.js";
+export * as types from "./test-types.js";
+export type { TestCase, TestCaseExpect, TestCheckResult, TestCaseResult, TestSpec, TestTargetResult, TestTargetRun, TestRunComparison, TestTargetType, } from "./lib/schema.js";
+export type { LoadedTestSpec, TestTargetCandidate, } from "./test-types.js";
+export type { TestSandboxRetentionMode, } from "./test-sandbox.js";

package/dist/packages/testing/index.js

@@ -0,0 +1,10 @@
+export * as schema from "./lib/schema.js";
+export * as test from "./test.js";
+export * as execution from "./test-execution.js";
+export * as matrices from "./test-matrices.js";
+export * as paths from "./test-paths.js";
+export * as profilePresets from "./test-profile-presets.js";
+export * as sandbox from "./test-sandbox.js";
+export * as specs from "./test-specs.js";
+export * as targets from "./test-targets.js";
+export * as types from "./test-types.js";

package/dist/packages/testing/lib/schema.d.ts

@@ -0,0 +1,261 @@
+import { z } from "zod";
+import { type TestCaseExpect, type TestTargetType } from "../../compiler/lib/schema.js";
+export declare const TestCaseSchema: z.ZodObject<{
+    id: z.ZodString;
+    question: z.ZodString;
+    file: z.ZodOptional<z.ZodString>;
+    answer: z.ZodOptional<z.ZodString>;
+    expect: z.ZodOptional<z.ZodObject<{
+        must_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        must_include_one_of: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
+        must_not_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        min_words: z.ZodOptional<z.ZodNumber>;
+        max_words: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    strictness: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const TestSpecSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        compiled: "compiled";
+        raw: "raw";
+    }>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    cases: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        question: z.ZodString;
+        file: z.ZodOptional<z.ZodString>;
+        answer: z.ZodOptional<z.ZodString>;
+        expect: z.ZodOptional<z.ZodObject<{
+            must_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            must_include_one_of: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
+            must_not_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            min_words: z.ZodOptional<z.ZodNumber>;
+            max_words: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        strictness: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const TestCheckResultSchema: z.ZodObject<{
+    label: z.ZodString;
+    ok: z.ZodBoolean;
+    detail: z.ZodString;
+}, z.core.$strip>;
+export declare const TestCaseResultSchema: z.ZodObject<{
+    caseId: z.ZodString;
+    question: z.ZodString;
+    file: z.ZodOptional<z.ZodString>;
+    ok: z.ZodBoolean;
+    wordCount: z.ZodNumber;
+    passedChecks: z.ZodNumber;
+    totalChecks: z.ZodNumber;
+    checks: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        ok: z.ZodBoolean;
+        detail: z.ZodString;
+    }, z.core.$strip>>;
+    answer: z.ZodOptional<z.ZodString>;
+    trace: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strip>;
+export declare const TestTargetResultSchema: z.ZodObject<{
+    target: z.ZodObject<{
+        type: z.ZodEnum<{
+            compiled: "compiled";
+            raw: "raw";
+        }>;
+        name: z.ZodString;
+        path: z.ZodString;
+        workflow: z.ZodString;
+    }, z.core.$strip>;
+    sandbox_path: z.ZodOptional<z.ZodString>;
+    ok: z.ZodBoolean;
+    passedCases: z.ZodNumber;
+    totalCases: z.ZodNumber;
+    passedChecks: z.ZodNumber;
+    totalChecks: z.ZodNumber;
+    caseResults: z.ZodArray<z.ZodObject<{
+        caseId: z.ZodString;
+        question: z.ZodString;
+        file: z.ZodOptional<z.ZodString>;
+        ok: z.ZodBoolean;
+        wordCount: z.ZodNumber;
+        passedChecks: z.ZodNumber;
+        totalChecks: z.ZodNumber;
+        checks: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            ok: z.ZodBoolean;
+            detail: z.ZodString;
+        }, z.core.$strip>>;
+        answer: z.ZodOptional<z.ZodString>;
+        trace: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const TestTargetRunSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-test-target-run">;
+    version: z.ZodLiteral<1>;
+    generated_at: z.ZodString;
+    spec: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        type: z.ZodEnum<{
+            compiled: "compiled";
+            raw: "raw";
+        }>;
+        file: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        case_count: z.ZodNumber;
+        cases: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            question: z.ZodString;
+            file: z.ZodOptional<z.ZodString>;
+            answer: z.ZodOptional<z.ZodString>;
+            strictness: z.ZodOptional<z.ZodString>;
+            expect: z.ZodOptional<z.ZodObject<{
+                must_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                must_include_one_of: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
+                must_not_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                min_words: z.ZodOptional<z.ZodNumber>;
+                max_words: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    source_path: z.ZodString;
+    executor: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            "local-agent": "local-agent";
+            "connected-provider": "connected-provider";
+            managed: "managed";
+        }>;
+        name: z.ZodString;
+        display_name: z.ZodString;
+        command: z.ZodNullable<z.ZodString>;
+        model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        effort: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        profile: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        timeout_ms: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>>;
+    target_count: z.ZodNumber;
+    results: z.ZodArray<z.ZodObject<{
+        target: z.ZodObject<{
+            type: z.ZodEnum<{
+                compiled: "compiled";
+                raw: "raw";
+            }>;
+            name: z.ZodString;
+            path: z.ZodString;
+            workflow: z.ZodString;
+        }, z.core.$strip>;
+        sandbox_path: z.ZodOptional<z.ZodString>;
+        ok: z.ZodBoolean;
+        passedCases: z.ZodNumber;
+        totalCases: z.ZodNumber;
+        passedChecks: z.ZodNumber;
+        totalChecks: z.ZodNumber;
+        caseResults: z.ZodArray<z.ZodObject<{
+            caseId: z.ZodString;
+            question: z.ZodString;
+            file: z.ZodOptional<z.ZodString>;
+            ok: z.ZodBoolean;
+            wordCount: z.ZodNumber;
+            passedChecks: z.ZodNumber;
+            totalChecks: z.ZodNumber;
+            checks: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                ok: z.ZodBoolean;
+                detail: z.ZodString;
+            }, z.core.$strip>>;
+            answer: z.ZodOptional<z.ZodString>;
+            trace: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const TestRunModeSchema: z.ZodEnum<{
+    compiled: "compiled";
+    raw: "raw";
+    both: "both";
+}>;
+export declare const TestRunTargetSummarySchema: z.ZodObject<{
+    label: z.ZodString;
+    run_path: z.ZodString;
+    ok: z.ZodBoolean;
+    passed_cases: z.ZodNumber;
+    total_cases: z.ZodNumber;
+    passed_checks: z.ZodNumber;
+    total_checks: z.ZodNumber;
+    target: z.ZodObject<{
+        type: z.ZodEnum<{
+            compiled: "compiled";
+            raw: "raw";
+        }>;
+        name: z.ZodString;
+        path: z.ZodString;
+        workflow: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const TestRunComparisonSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-test-run">;
+    version: z.ZodLiteral<1>;
+    generated_at: z.ZodString;
+    mode: z.ZodEnum<{
+        compiled: "compiled";
+        raw: "raw";
+        both: "both";
+    }>;
+    source_path: z.ZodString;
+    checks_fingerprint: z.ZodOptional<z.ZodString>;
+    dataset: z.ZodObject<{
+        name: z.ZodString;
+        compiled_path: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    raw: z.ZodNullable<z.ZodObject<{
+        label: z.ZodString;
+        run_path: z.ZodString;
+        ok: z.ZodBoolean;
+        passed_cases: z.ZodNumber;
+        total_cases: z.ZodNumber;
+        passed_checks: z.ZodNumber;
+        total_checks: z.ZodNumber;
+        target: z.ZodObject<{
+            type: z.ZodEnum<{
+                compiled: "compiled";
+                raw: "raw";
+            }>;
+            name: z.ZodString;
+            path: z.ZodString;
+            workflow: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    compiled: z.ZodNullable<z.ZodObject<{
+        label: z.ZodString;
+        run_path: z.ZodString;
+        ok: z.ZodBoolean;
+        passed_cases: z.ZodNumber;
+        total_cases: z.ZodNumber;
+        passed_checks: z.ZodNumber;
+        total_checks: z.ZodNumber;
+        target: z.ZodObject<{
+            type: z.ZodEnum<{
+                compiled: "compiled";
+                raw: "raw";
+            }>;
+            name: z.ZodString;
+            path: z.ZodString;
+            workflow: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    summary: z.ZodObject<{
+        raw_pass_rate: z.ZodNullable<z.ZodNumber>;
+        compiled_pass_rate: z.ZodNullable<z.ZodNumber>;
+        pass_rate_delta: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type { TestCaseExpect, TestTargetType };
+export type TestCase = z.infer<typeof TestCaseSchema>;
+export type TestSpec = z.infer<typeof TestSpecSchema>;
+export type TestCheckResult = z.infer<typeof TestCheckResultSchema>;
+export type TestCaseResult = z.infer<typeof TestCaseResultSchema>;
+export type TestTargetResult = z.infer<typeof TestTargetResultSchema>;
+export type TestTargetRun = z.infer<typeof TestTargetRunSchema>;
+export type TestRunMode = z.infer<typeof TestRunModeSchema>;
+export type TestRunTargetSummary = z.infer<typeof TestRunTargetSummarySchema>;
+export type TestRunComparison = z.infer<typeof TestRunComparisonSchema>;