@interf/compiler 0.16.0 → 0.21.0

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

@@ -1,11 +1,11 @@
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { buildTestSpecFromCompiledPreparationConfig, fingerprintReadinessChecks, } from "../../project/source-config.js";
-import { asPreparationDataDir, preparationLatestReadinessRunPath, preparationLatestReadinessSummaryPath, preparationTestRunPath, preparationTestRunsRoot, normalizePreparationTestRunId, preparationPortableContextPath, } from "../../contracts/lib/preparation-paths.js";
+import { buildTestSpecFromCompiledPreparationConfig, buildTestSpecFromSourceFolderConfig, fingerprintReadinessChecks, resolveConfiguredSourceFolderPath, resolveSourcePreparationPath, } from "../../project/source-config.js";
+import { asPreparationDataDir, preparationLatestReadinessRunPath, preparationLatestReadinessSummaryPath, preparationTestRunPath, preparationTestRunsRoot, preparationTestsRoot, normalizePreparationTestRunId, preparationPortableContextPath, } from "../../contracts/lib/preparation-paths.js";
 import { testRootForCompiled } from "../compile/compiled-paths.js";
 import { readJsonFileWithSchema } from "../../contracts/utils/parse.js";
 import { resolveMethodId } from "../../methods/method-resolution.js";
-import { createCompiledTestTarget, runTargetTestsAuto, saveTargetTestRun, } from "./test.js";
+import { createCompiledTestTarget, createSourceFilesTestTarget, runTargetTestsAuto, saveTargetTestRun, } from "./verify.js";
 import { ReadinessCheckRunSchema, } from "./lib/schema.js";
 export function readinessPassRate(outcome) {
     return outcome.result.totalCases > 0
@@ -80,33 +80,48 @@ export function readCurrentSavedReadinessCheckRun(options) {
     }
     return { readinessRun: latestRun, stale: false };
 }
+function modeForOutcomes(sourceFilesOutcome, compiledOutcome) {
+    if (sourceFilesOutcome && compiledOutcome)
+        return "both";
+    if (sourceFilesOutcome)
+        return "source-files";
+    return "compiled";
+}
+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 compiledSummary = options.compiledOutcome
         ? summarizeSavedTestOutcome("Portable Context", options.compiledOutcome)
         : null;
-    const compiledPassRate = compiledSummary
-        ? Math.round((compiledSummary.passed_cases / compiledSummary.total_cases) * 100)
-        : null;
     const payload = {
         kind: "interf-readiness-check-run",
         version: 1,
         generated_at: generatedAt,
-        // 0.15 — verify always runs in compiled-only mode. We keep the
-        // `mode: "compiled"` literal in the saved payload so existing
-        // dashboards / consumers that expect the field still parse.
-        mode: "compiled",
+        // 0.17 — verify carries the target it ran against on the wire so
+        // dashboards and the UI can show source-files baselines alongside
+        // compiled judgments. `both` is reserved for future combined runs.
+        mode: modeForOutcomes(sourceFilesOutcome, options.compiledOutcome),
         source_path: options.sourcePath,
         checks_fingerprint: options.checksFingerprint,
         preparation: {
             name: options.preparationName,
             portable_context_path: options.portableContextPath,
         },
-        source_files: null,
+        source_files: sourceFilesSummary,
         compiled: compiledSummary,
         summary: {
-            source_files_pass_rate: null,
-            portable_context_pass_rate: compiledPassRate,
+            source_files_pass_rate: passRateOf(sourceFilesSummary),
+            portable_context_pass_rate: passRateOf(compiledSummary),
         },
     };
     const latestStatePath = preparationLatestReadinessRunPath(asPreparationDataDir(options.sourcePath), options.preparationName);
@@ -156,19 +171,71 @@ export async function runSavedPortableContextCheck(options) {
         result,
     };
 }
-export async function runReadinessChecksForExecutor(options) {
-    // 0.15 — verify runs always judge against the compiled portable
-    // context. The legacy `source-files` and `both` modes were retired
-    // in 0.13.1 and removed from the wire shape here.
-    const compiledOutcome = await runSavedPortableContextCheck({
-        sourcePath: options.sourcePath,
-        preparationConfig: options.preparationConfig,
+/**
+ * 0.17 — restored. Runs the saved readiness checks against the source
+ * folder baseline (no portable-context indirection) so users can see how
+ * much value the Method 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,
-        portableContextPath: options.portableContextPath,
-        preserveSandboxes: options.preserveSandboxes,
+        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,
     });
-    const modeSatisfied = Boolean(compiledOutcome);
+    return {
+        runPath: preparationRunPath,
+        target,
+        result,
+    };
+}
+export async function runReadinessChecksForExecutor(options) {
+    const target = options.target ?? "compiled";
+    const compiledOutcome = target === "compiled"
+        ? await runSavedPortableContextCheck({
+            sourcePath: options.sourcePath,
+            preparationConfig: options.preparationConfig,
+            executor: options.executor,
+            portableContextPath: options.portableContextPath,
+            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(compiledOutcome) || Boolean(sourceFilesOutcome);
     const shouldSave = options.saveLatest !== false;
     const readinessRunPath = shouldSave && modeSatisfied
         ? saveReadinessCheckRun({
@@ -176,6 +243,7 @@ export async function runReadinessChecksForExecutor(options) {
             portableContextPath: options.portableContextPath,
             preparationName: options.preparationConfig.name,
             checksFingerprint: fingerprintReadinessChecks(options.preparationConfig.checks),
+            sourceFilesOutcome,
             compiledOutcome,
         })
         : null;
@@ -186,7 +254,7 @@ export async function runReadinessChecksForExecutor(options) {
         sourcePath: options.sourcePath,
         preparationConfig: options.preparationConfig,
         portableContextPath: options.portableContextPath,
-        sourceFilesOutcome: null,
+        sourceFilesOutcome,
         compiledOutcome,
         readinessRunPath,
         readinessRun,

package/dist/packages/engine/verify/{test-execution.d.ts → verify-execution.d.ts}

@@ -1,6 +1,6 @@
 import { type MethodExecutor } from "../agents/lib/executors.js";
-import type { TestTargetRun, TestTargetCandidate, LoadedTestSpec } from "./test-types.js";
-import { type TestSandboxRetentionMode } from "./test-sandbox.js";
+import type { TestTargetRun, TestTargetCandidate, LoadedTestSpec } from "./verify-types.js";
+import { type TestSandboxRetentionMode } from "./verify-sandbox.js";
 export declare function runTargetTests(sourcePath: string, spec: LoadedTestSpec, targets: TestTargetCandidate[]): TestTargetRun;
 export declare function runTargetTestsWithJudge(sourcePath: string, spec: LoadedTestSpec, targets: TestTargetCandidate[], executor: MethodExecutor, options?: {
     preserveSandboxes?: TestSandboxRetentionMode;

package/dist/packages/engine/verify/{test-execution.js → verify-execution.js}

@@ -2,8 +2,8 @@ import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { buildRuntimeExecutorInfo } from "../agents/lib/executors.js";
-import { targetTestRunGitignorePath, targetTestRunsPath, targetTestSandboxGitignorePath, targetTestSandboxesPath, normalizeTestId, } from "./test-paths.js";
-import { createTestSandbox, } from "./test-sandbox.js";
+import { targetTestRunGitignorePath, targetTestRunsPath, targetTestSandboxGitignorePath, targetTestSandboxesPath, normalizeTestId, } from "./verify-paths.js";
+import { createTestSandbox, } from "./verify-sandbox.js";
 function parseWords(content) {
     return content.trim().split(/\s+/).filter(Boolean).length;
 }
@@ -203,7 +203,7 @@ function buildTestQueryPrompt(target, testCase, answerPath, tracePath) {
             "Answer the check question the same way you would answer a real user inside this portable context.",
             "Prefer the Method-declared portable-context outputs before consulting source references.",
             "This sandbox is self-contained: the copied portable context has source references in `.interf/runtime/source-snapshot.json`.",
-            "The original Interf Workspace is intentionally absent from this sandbox. Use the source locators only when the portable context needs verification.",
+            "The original Interf instance state is intentionally absent from this sandbox. Use the source locators only when the portable context needs verification.",
         ]
         : [
             "You are running an Interf baseline test inside an isolated source-files test shell.",

package/dist/packages/engine/verify/{test-paths.d.ts → verify-paths.d.ts}

@@ -1,4 +1,4 @@
-import type { TestTargetType } from "./test-types.js";
+import type { TestTargetType } from "./verify-types.js";
 export declare const TEST_SPEC_EXTENSIONS: Set<string>;
 export declare function testSpecRootPath(sourcePath: string): string;
 export declare function testSpecTypePath(sourcePath: string, type: TestTargetType): string;

package/dist/packages/engine/verify/{test-sandbox.d.ts → verify-sandbox.d.ts}

@@ -1,4 +1,4 @@
-import type { TestTargetCandidate } from "./test-types.js";
+import type { TestTargetCandidate } from "./verify-types.js";
 export type TestSandboxRetentionMode = "on-failure" | "always";
 export interface TestSandbox {
     rootPath: string;

package/dist/packages/engine/verify/{test-specs.d.ts → verify-specs.d.ts}

@@ -1,4 +1,4 @@
-import type { TestSpec, TestTargetType, LoadedTestSpec } from "./test-types.js";
+import type { TestSpec, TestTargetType, LoadedTestSpec } from "./verify-types.js";
 export declare function listTestSpecs(sourcePath: string, type: TestTargetType): LoadedTestSpec[];
 export declare function loadTestSpec(sourcePath: string, type: TestTargetType, id: string): LoadedTestSpec | null;
 export declare function loadTestSpecFromFile(filePath: string): LoadedTestSpec | null;

package/dist/packages/engine/verify/{test-specs.js → verify-specs.js}

@@ -2,7 +2,7 @@ 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 "./test-paths.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))

package/dist/packages/engine/verify/{test-targets.d.ts → verify-targets.d.ts}

@@ -1,4 +1,4 @@
-import type { TestTargetCandidate } from "./test-types.js";
+import type { TestTargetCandidate } from "./verify-types.js";
 export declare function listCompiledTestTargets(sourcePath: string): TestTargetCandidate[];
 export declare function createCompiledTestTarget(compiledPath: string, compiledName: string, methodId?: string): TestTargetCandidate;
 export declare function createSourceFilesTestTarget(sourcePath: string): TestTargetCandidate;

package/dist/packages/engine/verify/{test.d.ts → verify.d.ts}

@@ -1,4 +1,4 @@
-export type { TestCaseExpect, TestCase, TestSpec, TestCheckResult, TestCaseResult, TestTargetResult, TestTargetRun, TestTargetType, LoadedTestSpec, TestTargetCandidate, } from "./test-types.js";
-export { listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, } from "./test-specs.js";
-export { createSourceFilesTestTarget, createCompiledTestTarget, listCompiledTestTargets, listTestTargets, } from "./test-targets.js";
-export { runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./test-execution.js";
+export type { TestCaseExpect, TestCase, TestSpec, TestCheckResult, TestCaseResult, TestTargetResult, TestTargetRun, TestTargetType, LoadedTestSpec, TestTargetCandidate, } from "./verify-types.js";
+export { listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, } from "./verify-specs.js";
+export { createSourceFilesTestTarget, createCompiledTestTarget, listCompiledTestTargets, listTestTargets, } from "./verify-targets.js";
+export { runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./verify-execution.js";

package/dist/packages/engine/verify/{test.js → verify.js}

@@ -1,3 +1,3 @@
-export { listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, } from "./test-specs.js";
-export { createSourceFilesTestTarget, createCompiledTestTarget, listCompiledTestTargets, listTestTargets, } from "./test-targets.js";
-export { runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./test-execution.js";
+export { listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, } from "./verify-specs.js";
+export { createSourceFilesTestTarget, createCompiledTestTarget, listCompiledTestTargets, listTestTargets, } from "./verify-targets.js";
+export { runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./verify-execution.js";