@interf/compiler 0.22.2 → 0.50.0

package/dist/packages/engine/verify/readiness-check-run.d.ts

@@ -1,82 +0,0 @@
-import type { AgentExecutor } from "../agents/lib/executors.js";
-import type { SourcePreparationConfig } from "../../project/lib/schema.js";
-import type { TestTargetType } from "../../contracts/lib/schema.js";
-import { type TestTargetCandidate, type TestTargetResult } from "./verify.js";
-import type { TestSandboxRetentionMode } from "./verify-sandbox.js";
-import { type ReadinessCheckRun } from "./lib/schema.js";
-export interface SavedReadinessCheckOutcome {
-    runPath: string;
-    displayRunPath?: string;
-    target: TestTargetCandidate;
-    result: TestTargetResult;
-}
-export interface ReadinessCheckRunResult {
-    sourcePath: string;
-    preparationConfig: SourcePreparationConfig;
-    verifiableContextPath: string | null;
-    /**
-     * 0.17 — restored. Populated when the verify run targets
-     * `source-files`; null when targeting verifiable context. Aggregates back
-     * onto the saved `ReadinessCheckRun` payload's `source_files` field.
-     */
-    sourceFilesOutcome: SavedReadinessCheckOutcome | null;
-    verifiableContextOutcome: SavedReadinessCheckOutcome | null;
-    readinessRunPath: string | null;
-    readinessRun: ReadinessCheckRun | null;
-}
-export declare function readinessPassRate(outcome: SavedReadinessCheckOutcome): number;
-export declare function readSavedReadinessCheckRun(prepDataDir: string, preparationName: string): ReadinessCheckRun | null;
-export declare function parseReadinessCheckRun(value: unknown): ReadinessCheckRun | null;
-export declare function readReadinessCheckRunAtPath(filePath: string, label?: string): ReadinessCheckRun | null;
-export declare function readCurrentSavedReadinessCheckRun(options: {
-    prepDataDir: string;
-    preparationName: string;
-    checks: SourcePreparationConfig["checks"];
-}): {
-    readinessRun: ReadinessCheckRun | null;
-    stale: boolean;
-};
-export declare function saveReadinessCheckRun(options: {
-    sourcePath: string;
-    verifiableContextPath: string | null;
-    preparationName: string;
-    checksFingerprint: string;
-    sourceFilesOutcome?: SavedReadinessCheckOutcome | null;
-    verifiableContextOutcome: SavedReadinessCheckOutcome | null;
-}): string;
-export declare function runSavedVerifiableContextCheck(options: {
-    sourcePath: string;
-    preparationConfig: SourcePreparationConfig;
-    executor?: AgentExecutor | null;
-    verifiableContextPath?: string | null;
-    preserveSandboxes?: TestSandboxRetentionMode;
-    runSuffix?: string | null;
-}): Promise<SavedReadinessCheckOutcome | null>;
-/**
- * 0.17 — restored. Runs the saved readiness checks against the source
- * folder baseline (no verifiable-context indirection) so users can see how
- * much value the Build Plan actually adds. The lower-level `verify-execution`
- * + `verify-sandbox` source-files paths have stayed in tree since 0.13;
- * this is the orchestrator hook that was missing.
- */
-export declare function runSavedSourceFilesCheck(options: {
-    sourcePath: string;
-    preparationConfig: SourcePreparationConfig;
-    executor?: AgentExecutor | null;
-    preserveSandboxes?: TestSandboxRetentionMode;
-    runSuffix?: string | null;
-}): Promise<SavedReadinessCheckOutcome | null>;
-export declare function runReadinessChecksForExecutor(options: {
-    sourcePath: string;
-    preparationConfig: SourcePreparationConfig;
-    verifiableContextPath: string | null;
-    executor?: AgentExecutor | null;
-    preserveSandboxes?: TestSandboxRetentionMode;
-    runSuffix?: string | null;
-    saveLatest?: boolean;
-    /**
-     * 0.17 — selects which target the readiness checks judge against.
-     * Defaults to verifiable context.
-     */
-    target?: TestTargetType;
-}): Promise<ReadinessCheckRunResult>;

package/dist/packages/engine/verify/readiness-check-run.js

@@ -1,265 +0,0 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { buildTestSpecFromPreparationConfig, buildTestSpecFromSourceFolderConfig, fingerprintReadinessChecks, resolveConfiguredSourceFolderPath, resolveSourcePreparationPath, } from "../../project/source-config.js";
-import { asPreparationDataDir, preparationLatestReadinessRunPath, preparationLatestReadinessSummaryPath, preparationTestRunPath, preparationTestRunsRoot, preparationTestsRoot, normalizePreparationTestRunId, preparationVerifiableContextPath, } from "../../contracts/lib/preparation-paths.js";
-import { testRootForVerifiableContext } from "../build/verifiable-context-paths.js";
-import { readJsonFileWithSchema } from "../../contracts/utils/parse.js";
-import { resolveBuildPlanId } from "../../build-plans/build-plan-resolution.js";
-import { createVerifiableContextTestTarget, createSourceFilesTestTarget, runTargetTestsAuto, saveTargetTestRun, } from "./verify.js";
-import { ReadinessCheckRunSchema, } from "./lib/schema.js";
-export function readinessPassRate(outcome) {
-    return outcome.result.totalCases > 0
-        ? Math.round((outcome.result.passedCases / outcome.result.totalCases) * 100)
-        : 0;
-}
-function visibleRunPath(outcome) {
-    return outcome.displayRunPath ?? outcome.runPath;
-}
-function summarizeSavedTestOutcome(label, outcome) {
-    return {
-        label,
-        run_path: visibleRunPath(outcome),
-        ok: outcome.result.ok,
-        passed_cases: outcome.result.passedCases,
-        total_cases: outcome.result.totalCases,
-        passed_checks: outcome.result.passedChecks,
-        total_checks: outcome.result.totalChecks,
-        target: outcome.target,
-    };
-}
-function writePreparationTargetRun(options) {
-    const dirPath = preparationTestRunsRoot(asPreparationDataDir(options.prepDataDir), options.preparationName, options.target);
-    mkdirSync(dirPath, { recursive: true });
-    const runPath = preparationTestRunPath(asPreparationDataDir(options.prepDataDir), options.preparationName, options.target, options.generatedAt, options.runId, options.runSuffix);
-    writeFileSync(runPath, `${JSON.stringify(options.payload, null, 2)}\n`);
-    return runPath;
-}
-function renderLatestSummaryMarkdown(payload) {
-    const lines = [
-        "# Latest Readiness Results",
-        "",
-        "| Target | Readiness checks |",
-        "| --- | --- |",
-    ];
-    if (payload.source_files) {
-        lines.push(`| Source files | \`${payload.source_files.passed_cases}/${payload.source_files.total_cases}\` |`);
-    }
-    if (payload.verifiable_context) {
-        lines.push(`| Verifiable Context | \`${payload.verifiable_context.passed_cases}/${payload.verifiable_context.total_cases}\` |`);
-    }
-    lines.push("");
-    if (payload.source_files) {
-        lines.push(`- Latest source-files run: ${payload.source_files.run_path}`);
-    }
-    if (payload.verifiable_context) {
-        lines.push(`- Latest verifiable-context run: ${payload.verifiable_context.run_path}`);
-    }
-    return `${lines.join("\n")}\n`;
-}
-export function readSavedReadinessCheckRun(prepDataDir, preparationName) {
-    const latestPath = preparationLatestReadinessRunPath(asPreparationDataDir(prepDataDir), preparationName);
-    if (!existsSync(latestPath))
-        return null;
-    return readReadinessCheckRunAtPath(latestPath, "latest readiness-check run");
-}
-export function parseReadinessCheckRun(value) {
-    const parsed = ReadinessCheckRunSchema.safeParse(value);
-    return parsed.success ? parsed.data : null;
-}
-export function readReadinessCheckRunAtPath(filePath, label = "readiness-check run") {
-    return readJsonFileWithSchema(filePath, label, ReadinessCheckRunSchema);
-}
-export function readCurrentSavedReadinessCheckRun(options) {
-    const latestRun = readSavedReadinessCheckRun(options.prepDataDir, options.preparationName);
-    if (!latestRun) {
-        return { readinessRun: null, stale: false };
-    }
-    const currentFingerprint = fingerprintReadinessChecks(options.checks);
-    if (!latestRun.checks_fingerprint || latestRun.checks_fingerprint !== currentFingerprint) {
-        return { readinessRun: null, stale: true };
-    }
-    return { readinessRun: latestRun, stale: false };
-}
-function modeForOutcomes(sourceFilesOutcome, verifiableContextOutcome) {
-    if (sourceFilesOutcome && verifiableContextOutcome)
-        return "both";
-    if (sourceFilesOutcome)
-        return "source-files";
-    return "verifiable-context";
-}
-function passRateOf(summary) {
-    if (!summary)
-        return null;
-    if (summary.total_cases <= 0)
-        return 0;
-    return Math.round((summary.passed_cases / summary.total_cases) * 100);
-}
-export function saveReadinessCheckRun(options) {
-    const generatedAt = new Date().toISOString();
-    const sourceFilesOutcome = options.sourceFilesOutcome ?? null;
-    const sourceFilesSummary = sourceFilesOutcome
-        ? summarizeSavedTestOutcome("Source Files", sourceFilesOutcome)
-        : null;
-    const verifiableContextSummary = options.verifiableContextOutcome
-        ? summarizeSavedTestOutcome("Verifiable Context", options.verifiableContextOutcome)
-        : null;
-    const payload = {
-        kind: "interf-readiness-check-run",
-        version: 1,
-        generated_at: generatedAt,
-        // 0.17 — verify carries the target it ran against on the wire so
-        // dashboards and the UI can show source-files baselines alongside
-        // verifiable-context judgments. `both` is reserved for future combined runs.
-        mode: modeForOutcomes(sourceFilesOutcome, options.verifiableContextOutcome),
-        source_path: options.sourcePath,
-        checks_fingerprint: options.checksFingerprint,
-        preparation: {
-            name: options.preparationName,
-            verifiable_context_path: options.verifiableContextPath,
-        },
-        source_files: sourceFilesSummary,
-        verifiable_context: verifiableContextSummary,
-        summary: {
-            source_files_pass_rate: passRateOf(sourceFilesSummary),
-            verifiable_context_pass_rate: passRateOf(verifiableContextSummary),
-        },
-    };
-    const latestStatePath = preparationLatestReadinessRunPath(asPreparationDataDir(options.sourcePath), options.preparationName);
-    mkdirSync(dirname(latestStatePath), { recursive: true });
-    writeFileSync(latestStatePath, `${JSON.stringify(payload, null, 2)}\n`);
-    writeFileSync(preparationLatestReadinessSummaryPath(asPreparationDataDir(options.sourcePath), options.preparationName), renderLatestSummaryMarkdown(payload));
-    if (options.verifiableContextPath) {
-        mkdirSync(testRootForVerifiableContext(options.verifiableContextPath), { recursive: true });
-        writeFileSync(join(testRootForVerifiableContext(options.verifiableContextPath), "latest.json"), `${JSON.stringify(payload, null, 2)}\n`);
-    }
-    return latestStatePath;
-}
-export async function runSavedVerifiableContextCheck(options) {
-    const verifiableContextPath = options.verifiableContextPath
-        ?? verifiableContextPathForPreparation(options.sourcePath, options.preparationConfig.name);
-    const spec = buildTestSpecFromPreparationConfig({
-        verifiableContextPath: verifiableContextPath,
-        targetType: "verifiable-context",
-    });
-    if (!spec)
-        return null;
-    const target = createVerifiableContextTestTarget(verifiableContextPath, options.preparationConfig.name, resolveBuildPlanId(options.preparationConfig));
-    if (!target.eligible)
-        return null;
-    const run = await runTargetTestsAuto(options.sourcePath, spec, [target], {
-        executor: options.executor,
-        preserveSandboxes: options.preserveSandboxes ?? "on-failure",
-        artifactRootPath: verifiableContextPath,
-    });
-    const result = run.results[0];
-    if (!result)
-        return null;
-    const verifiableContextRunPath = saveTargetTestRun(verifiableContextPath, run);
-    const preparationRunPath = writePreparationTargetRun({
-        prepDataDir: options.sourcePath,
-        preparationName: options.preparationConfig.name,
-        target: "verifiable-context",
-        generatedAt: run.generated_at,
-        runId: normalizePreparationTestRunId(spec.id),
-        runSuffix: options.runSuffix,
-        payload: run,
-    });
-    return {
-        runPath: verifiableContextRunPath,
-        displayRunPath: preparationRunPath,
-        target,
-        result,
-    };
-}
-/**
- * 0.17 — restored. Runs the saved readiness checks against the source
- * folder baseline (no verifiable-context indirection) so users can see how
- * much value the Build Plan actually adds. The lower-level `verify-execution`
- * + `verify-sandbox` source-files paths have stayed in tree since 0.13;
- * this is the orchestrator hook that was missing.
- */
-export async function runSavedSourceFilesCheck(options) {
-    const spec = buildTestSpecFromSourceFolderConfig({
-        prepDataDir: options.sourcePath,
-        targetName: options.preparationConfig.name,
-        targetType: "source-files",
-    });
-    if (!spec)
-        return null;
-    const sourceFolderPath = resolveConfiguredSourceFolderPath(options.sourcePath) ??
-        resolveSourcePreparationPath(options.sourcePath, options.preparationConfig);
-    const target = createSourceFilesTestTarget(sourceFolderPath);
-    if (!target.eligible)
-        return null;
-    const run = await runTargetTestsAuto(sourceFolderPath, spec, [target], {
-        executor: options.executor,
-        preserveSandboxes: options.preserveSandboxes ?? "on-failure",
-        artifactRootPath: preparationTestsRoot(asPreparationDataDir(options.sourcePath), options.preparationConfig.name),
-    });
-    const result = run.results[0];
-    if (!result)
-        return null;
-    const preparationRunPath = writePreparationTargetRun({
-        prepDataDir: options.sourcePath,
-        preparationName: options.preparationConfig.name,
-        target: "source-files",
-        generatedAt: run.generated_at,
-        runId: normalizePreparationTestRunId(spec.id),
-        runSuffix: options.runSuffix,
-        payload: run,
-    });
-    return {
-        runPath: preparationRunPath,
-        target,
-        result,
-    };
-}
-export async function runReadinessChecksForExecutor(options) {
-    const target = options.target ?? "verifiable-context";
-    const verifiableContextOutcome = target === "verifiable-context"
-        ? await runSavedVerifiableContextCheck({
-            sourcePath: options.sourcePath,
-            preparationConfig: options.preparationConfig,
-            executor: options.executor,
-            verifiableContextPath: options.verifiableContextPath,
-            preserveSandboxes: options.preserveSandboxes,
-            runSuffix: options.runSuffix,
-        })
-        : null;
-    const sourceFilesOutcome = target === "source-files"
-        ? await runSavedSourceFilesCheck({
-            sourcePath: options.sourcePath,
-            preparationConfig: options.preparationConfig,
-            executor: options.executor,
-            preserveSandboxes: options.preserveSandboxes,
-            runSuffix: options.runSuffix,
-        })
-        : null;
-    const modeSatisfied = Boolean(verifiableContextOutcome) || Boolean(sourceFilesOutcome);
-    const shouldSave = options.saveLatest !== false;
-    const readinessRunPath = shouldSave && modeSatisfied
-        ? saveReadinessCheckRun({
-            sourcePath: options.sourcePath,
-            verifiableContextPath: options.verifiableContextPath,
-            preparationName: options.preparationConfig.name,
-            checksFingerprint: fingerprintReadinessChecks(options.preparationConfig.checks),
-            sourceFilesOutcome,
-            verifiableContextOutcome,
-        })
-        : null;
-    const readinessRun = shouldSave && modeSatisfied
-        ? readSavedReadinessCheckRun(options.sourcePath, options.preparationConfig.name)
-        : null;
-    return {
-        sourcePath: options.sourcePath,
-        preparationConfig: options.preparationConfig,
-        verifiableContextPath: options.verifiableContextPath,
-        sourceFilesOutcome,
-        verifiableContextOutcome,
-        readinessRunPath,
-        readinessRun,
-    };
-}
-function verifiableContextPathForPreparation(sourcePath, preparationName) {
-    return preparationVerifiableContextPath(asPreparationDataDir(sourcePath), preparationName);
-}

package/dist/packages/engine/verify/verify-paths.js

@@ -1,61 +0,0 @@
-import { existsSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
-import { targetTestRunsRootForVerifiableContext, targetTestSandboxesRootForVerifiableContext, verifiableContextInterfConfigPath, } from "../build/verifiable-context-paths.js";
-import { asPreparationDataDir, preparationTestsSpecsRoot, } from "../../contracts/lib/preparation-paths.js";
-const TEST_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,79}$/;
-export const TEST_SPEC_EXTENSIONS = new Set([".json"]);
-export function testSpecRootPath(sourcePath) {
-    return preparationTestsSpecsRoot(asPreparationDataDir(sourcePath));
-}
-export function testSpecTypePath(sourcePath, type) {
-    return join(testSpecRootPath(sourcePath), type);
-}
-function isPreparationTestsRootPath(artifactRootPath) {
-    return basename(artifactRootPath) === "tests" &&
-        basename(dirname(artifactRootPath)) === ".interf";
-}
-export function targetTestRunsPath(verifiableContextPath, type) {
-    if (existsSync(verifiableContextInterfConfigPath(verifiableContextPath))) {
-        return join(targetTestRunsRootForVerifiableContext(verifiableContextPath), type);
-    }
-    if (isPreparationTestsRootPath(verifiableContextPath)) {
-        return join(verifiableContextPath, type === "source-files" ? "source-files" : "verifiable-context", "runs");
-    }
-    throw new Error(`Unsupported test artifact root: ${verifiableContextPath}. Expected verifiable context or interf/<preparation>/.interf/tests root.`);
-}
-export function targetTestRunGitignorePath(verifiableContextPath, type) {
-    return join(targetTestRunsPath(verifiableContextPath, type), ".gitignore");
-}
-export function targetTestSandboxesPath(verifiableContextPath, type) {
-    if (existsSync(verifiableContextInterfConfigPath(verifiableContextPath))) {
-        return join(targetTestSandboxesRootForVerifiableContext(verifiableContextPath), type);
-    }
-    if (isPreparationTestsRootPath(verifiableContextPath)) {
-        return join(verifiableContextPath, type === "source-files" ? "source-files" : "verifiable-context", "sandboxes");
-    }
-    throw new Error(`Unsupported test artifact root: ${verifiableContextPath}. Expected verifiable context or interf/<preparation>/.interf/tests root.`);
-}
-export function targetTestSandboxGitignorePath(verifiableContextPath, type) {
-    return join(targetTestSandboxesPath(verifiableContextPath, type), ".gitignore");
-}
-export function testSpecFilePath(sourcePath, type, id) {
-    return join(testSpecTypePath(sourcePath, type), `${id}.json`);
-}
-export function normalizeTestId(input) {
-    return input
-        .toLowerCase()
-        .trim()
-        .replace(/[^a-z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .slice(0, 80);
-}
-export function assertTestId(id) {
-    if (!TEST_ID_PATTERN.test(id)) {
-        throw new Error(`Invalid test id: ${id}`);
-    }
-}
-export function assertWritableTestSpecPath(filePath) {
-    if (existsSync(filePath)) {
-        throw new Error(`Test spec already exists: ${filePath}`);
-    }
-}

package/dist/packages/engine/verify/verify-sandbox.js

@@ -1,88 +0,0 @@
-import { cpSync, mkdirSync, mkdtempSync, renameSync, rmSync, writeFileSync, } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { refreshVerifiableContextBootstrapGuidance } from "../agents/lib/verifiable-context-bootstrap.js";
-import { readInterfConfig, resolveSourceInputPath } from "../../project/interf.js";
-import { projectSourceFilesTestQueryShell } from "../agents/lib/shells.js";
-import { asPreparationDataDir, preparationVerifiableContextPath, } from "../../contracts/lib/preparation-paths.js";
-import { saveVerifiableContextInterfConfig } from "../../project/source-config.js";
-import { buildVerifiableContextSourceFiles } from "../build/source-files.js";
-import { refreshVerifiableContextArtifacts } from "../build/state.js";
-import { testRootForVerifiableContext, stageExecutionShellsRoot, targetTestSandboxesRootForVerifiableContext, buildPlanImprovementLoopsRoot, verifiableContextQueryAcceptanceRoot, verifiableContextRuntimeLogsRoot, } from "../build/verifiable-context-paths.js";
-function sanitizeVerifiableContextArtifacts(verifiableContextPath) {
-    for (const absolutePath of [
-        testRootForVerifiableContext(verifiableContextPath),
-        targetTestSandboxesRootForVerifiableContext(verifiableContextPath),
-        stageExecutionShellsRoot(verifiableContextPath),
-        buildPlanImprovementLoopsRoot(verifiableContextPath),
-        verifiableContextRuntimeLogsRoot(verifiableContextPath),
-        verifiableContextQueryAcceptanceRoot(verifiableContextPath),
-    ]) {
-        rmSync(absolutePath, { recursive: true, force: true });
-    }
-}
-export function createTestSandbox(target) {
-    let sandboxRoot = mkdtempSync(join(tmpdir(), "interf-test-sandbox-"));
-    let preserved = false;
-    const sandboxVerifiableContextPath = () => (target.type === "verifiable-context"
-        ? preparationVerifiableContextPath(asPreparationDataDir(sandboxRoot), target.name)
-        : null);
-    const sandboxTargetPath = () => (target.type === "verifiable-context"
-        ? preparationVerifiableContextPath(asPreparationDataDir(sandboxRoot), target.name)
-        : sandboxRoot);
-    try {
-        if (target.type === "verifiable-context") {
-            const sourceInputPath = resolveSourceInputPath(target.path);
-            mkdirSync(dirname(sandboxTargetPath()), { recursive: true });
-            cpSync(target.path, sandboxTargetPath(), { recursive: true });
-            sanitizeVerifiableContextArtifacts(sandboxTargetPath());
-            const sandboxConfig = readInterfConfig(sandboxTargetPath());
-            if (!sandboxConfig) {
-                throw new Error(`Sandbox verifiable context is missing interf.json: ${sandboxTargetPath()}`);
-            }
-            saveVerifiableContextInterfConfig(sandboxTargetPath(), {
-                ...sandboxConfig,
-                checks: [],
-                source: {
-                    path: sourceInputPath,
-                    preparation_path: sourceInputPath,
-                },
-            });
-            refreshVerifiableContextBootstrapGuidance(sandboxTargetPath());
-            refreshVerifiableContextArtifacts(sandboxTargetPath(), { ensureViewSpec: true });
-        }
-        else {
-            mkdirSync(join(sandboxTargetPath(), "runtime"), { recursive: true });
-            writeFileSync(join(sandboxTargetPath(), "runtime", "source-files.json"), `${JSON.stringify(buildVerifiableContextSourceFiles(sandboxTargetPath(), target.path), null, 2)}\n`);
-            projectSourceFilesTestQueryShell(sandboxTargetPath());
-        }
-    }
-    catch (error) {
-        rmSync(sandboxRoot, { recursive: true, force: true });
-        throw error;
-    }
-    return {
-        get rootPath() {
-            return sandboxRoot;
-        },
-        get targetPath() {
-            return sandboxTargetPath();
-        },
-        get verifiableContextPath() {
-            return sandboxVerifiableContextPath();
-        },
-        preserve(destinationPath) {
-            mkdirSync(dirname(destinationPath), { recursive: true });
-            rmSync(destinationPath, { recursive: true, force: true });
-            renameSync(sandboxRoot, destinationPath);
-            sandboxRoot = destinationPath;
-            preserved = true;
-            return sandboxRoot;
-        },
-        cleanup() {
-            if (preserved)
-                return;
-            rmSync(sandboxRoot, { recursive: true, force: true });
-        },
-    };
-}

package/dist/packages/engine/verify/verify-specs.js

@@ -1,114 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, writeFileSync, } from "node:fs";
-import { basename, extname, join } from "node:path";
-import { readJsonFileWithSchema } from "../../contracts/utils/parse.js";
-import { TestSpecSchema } from "./lib/schema.js";
-import { TEST_SPEC_EXTENSIONS, assertTestId, assertWritableTestSpecPath, testSpecFilePath, testSpecTypePath, normalizeTestId, } from "./verify-paths.js";
-function readTestSpecFile(filePath) {
-    const extension = extname(filePath).toLowerCase();
-    if (!TEST_SPEC_EXTENSIONS.has(extension))
-        return null;
-    const parsed = readJsonFileWithSchema(filePath, "test spec", TestSpecSchema);
-    if (!parsed)
-        return null;
-    return {
-        ...parsed,
-        id: basename(filePath, extension),
-        filePath,
-    };
-}
-function serializeTestSpec(spec) {
-    return {
-        type: spec.type,
-        name: spec.name,
-        ...(spec.description ? { description: spec.description } : {}),
-        cases: spec.cases.map((testCase) => ({
-            id: testCase.id,
-            question: testCase.question,
-            ...(testCase.file ? { file: testCase.file } : {}),
-            ...(testCase.answer ? { answer: testCase.answer } : {}),
-            ...(testCase.strictness ? { strictness: testCase.strictness } : {}),
-            ...(testCase.expect ? { expect: testCase.expect } : {}),
-        })),
-    };
-}
-export function listTestSpecs(sourcePath, type) {
-    const dirPath = testSpecTypePath(sourcePath, type);
-    if (!existsSync(dirPath))
-        return [];
-    return readdirSync(dirPath)
-        .map((entry) => join(dirPath, entry))
-        .filter((filePath) => TEST_SPEC_EXTENSIONS.has(extname(filePath).toLowerCase()))
-        .map((filePath) => readTestSpecFile(filePath))
-        .filter((value) => value !== null)
-        .sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
-}
-export function loadTestSpec(sourcePath, type, id) {
-    const normalizedId = normalizeTestId(id);
-    const filePath = join(testSpecTypePath(sourcePath, type), `${normalizedId}.json`);
-    if (!existsSync(filePath))
-        return null;
-    return readTestSpecFile(filePath);
-}
-export function loadTestSpecFromFile(filePath) {
-    return readTestSpecFile(filePath);
-}
-export function writeTestSpec(sourcePath, spec) {
-    const id = normalizeTestId(spec.id ?? spec.name);
-    assertTestId(id);
-    const dirPath = testSpecTypePath(sourcePath, spec.type);
-    mkdirSync(dirPath, { recursive: true });
-    const existingPath = join(dirPath, `${id}.json`);
-    if (existsSync(existingPath)) {
-        throw new Error(`Test spec already exists: ${existingPath}`);
-    }
-    const filePath = testSpecFilePath(sourcePath, spec.type, id);
-    assertWritableTestSpecPath(filePath);
-    const normalizedSpec = {
-        type: spec.type,
-        name: spec.name.trim(),
-        ...(spec.description && spec.description.trim().length > 0
-            ? { description: spec.description.trim() }
-            : {}),
-        cases: spec.cases.map((testCase) => ({
-            id: normalizeTestId(testCase.id),
-            question: testCase.question.trim(),
-            ...(testCase.file && testCase.file.trim().length > 0
-                ? { file: testCase.file.trim() }
-                : {}),
-            ...(testCase.answer && testCase.answer.trim().length > 0
-                ? { answer: testCase.answer.trim() }
-                : {}),
-            ...(testCase.strictness && testCase.strictness.trim().length > 0
-                ? { strictness: testCase.strictness.trim() }
-                : {}),
-            ...(testCase.expect
-                ? {
-                    expect: {
-                        ...(testCase.expect.must_include && testCase.expect.must_include.length > 0
-                            ? { must_include: testCase.expect.must_include.map((value) => value.trim()).filter(Boolean) }
-                            : {}),
-                        ...(testCase.expect.must_include_one_of && testCase.expect.must_include_one_of.length > 0
-                            ? {
-                                must_include_one_of: testCase.expect.must_include_one_of
-                                    .map((group) => group.map((value) => value.trim()).filter(Boolean))
-                                    .filter((group) => group.length > 0),
-                            }
-                            : {}),
-                        ...(testCase.expect.must_not_include && testCase.expect.must_not_include.length > 0
-                            ? { must_not_include: testCase.expect.must_not_include.map((value) => value.trim()).filter(Boolean) }
-                            : {}),
-                        ...(typeof testCase.expect.min_words === "number"
-                            ? { min_words: testCase.expect.min_words }
-                            : {}),
-                        ...(typeof testCase.expect.max_words === "number"
-                            ? { max_words: testCase.expect.max_words }
-                            : {}),
-                    },
-                }
-                : {}),
-        })),
-    };
-    const parsed = TestSpecSchema.parse(normalizedSpec);
-    writeFileSync(filePath, `${JSON.stringify(serializeTestSpec(parsed), null, 2)}\n`);
-    return filePath;
-}

package/dist/packages/engine/verify/verify-targets.d.ts

@@ -1,5 +0,0 @@
-import type { TestTargetCandidate } from "./verify-types.js";
-export declare function listVerifiableContextTestTargets(sourcePath: string): TestTargetCandidate[];
-export declare function createVerifiableContextTestTarget(verifiableContextPath: string, verifiableContextName: string, buildPlanId?: string): TestTargetCandidate;
-export declare function createSourceFilesTestTarget(sourcePath: string): TestTargetCandidate;
-export declare function listTestTargets(sourcePath: string): TestTargetCandidate[];