@interf/compiler 0.13.0 → 0.18.0

package/dist/packages/{testing → 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, buildTestSpecFromSourceFolderConfig, fingerprintReadinessChecks, resolveSourcePreparationPath, } from "../project-model/source-config.js";
-import { asPreparationDataDir, preparationLatestReadinessRunPath, preparationLatestReadinessSummaryPath, preparationTestRunPath, preparationTestRunsRoot, normalizePreparationTestRunId, preparationPortableContextPath, } from "../contracts/lib/preparation-paths.js";
-import { testRootForCompiled } from "../compiler/compiled-paths.js";
-import { readJsonFileWithSchema } from "../shared/parse.js";
-import { resolveMethodId } from "../methods/method-resolution.js";
-import { createCompiledTestTarget, createSourceFilesTestTarget, runTargetTestsAuto, saveTargetTestRun, } from "./test.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, createSourceFilesTestTarget, runTargetTestsAuto, saveTargetTestRun, } from "./verify.js";
 import { ReadinessCheckRunSchema, } from "./lib/schema.js";
 export function readinessPassRate(outcome) {
     return outcome.result.totalCases > 0
@@ -80,30 +80,37 @@ 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 sourceFilesSummary = options.sourceFilesOutcome
-        ? summarizeSavedTestOutcome("Source files", options.sourceFilesOutcome)
+    const sourceFilesOutcome = options.sourceFilesOutcome ?? null;
+    const sourceFilesSummary = sourceFilesOutcome
+        ? summarizeSavedTestOutcome("Source Files", sourceFilesOutcome)
         : null;
     const compiledSummary = options.compiledOutcome
         ? summarizeSavedTestOutcome("Portable Context", options.compiledOutcome)
         : null;
-    const effectiveMode = sourceFilesSummary && compiledSummary
-        ? "both"
-        : sourceFilesSummary
-            ? "source-files"
-            : "compiled";
-    const sourceFilesPassRate = sourceFilesSummary
-        ? Math.round((sourceFilesSummary.passed_cases / sourceFilesSummary.total_cases) * 100)
-        : 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,
-        mode: effectiveMode,
+        // 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: {
@@ -113,8 +120,8 @@ export function saveReadinessCheckRun(options) {
         source_files: sourceFilesSummary,
         compiled: compiledSummary,
         summary: {
-            source_files_pass_rate: sourceFilesPassRate,
-            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);
@@ -127,101 +134,108 @@ export function saveReadinessCheckRun(options) {
     }
     return latestStatePath;
 }
-export async function runSavedSourceFilesCheck(options) {
-    const spec = buildTestSpecFromSourceFolderConfig({
-        prepDataDir: options.sourcePath,
-        targetName: options.preparationConfig.name,
-        targetType: "source-files",
+export async function runSavedPortableContextCheck(options) {
+    const portableContextPath = options.portableContextPath
+        ?? portableContextPathForPreparation(options.sourcePath, options.preparationConfig.name);
+    const spec = buildTestSpecFromCompiledPreparationConfig({
+        compiledPath: portableContextPath,
+        targetType: "compiled",
     });
     if (!spec)
         return null;
-    const sourceFolderPath = resolveSourcePreparationPath(options.sourcePath, options.preparationConfig);
-    const target = createSourceFilesTestTarget(sourceFolderPath);
-    const artifactRoot = preparationLatestReadinessRunPath(asPreparationDataDir(options.sourcePath), options.preparationConfig.name);
-    const run = await runTargetTestsAuto(sourceFolderPath, spec, [target], {
+    const target = createCompiledTestTarget(portableContextPath, options.preparationConfig.name, resolveMethodId(options.preparationConfig));
+    if (!target.eligible)
+        return null;
+    const run = await runTargetTestsAuto(options.sourcePath, spec, [target], {
         executor: options.executor,
         preserveSandboxes: options.preserveSandboxes ?? "on-failure",
-        artifactRootPath: dirname(artifactRoot),
+        artifactRootPath: portableContextPath,
     });
     const result = run.results[0];
     if (!result)
         return null;
+    const compiledRunPath = saveTargetTestRun(portableContextPath, run);
     const preparationRunPath = writePreparationTargetRun({
         prepDataDir: options.sourcePath,
         preparationName: options.preparationConfig.name,
-        target: "source-files",
+        target: "compiled",
         generatedAt: run.generated_at,
         runId: normalizePreparationTestRunId(spec.id),
         runSuffix: options.runSuffix,
         payload: run,
     });
     return {
-        runPath: preparationRunPath,
+        runPath: compiledRunPath,
+        displayRunPath: preparationRunPath,
         target,
         result,
     };
 }
-export async function runSavedPortableContextCheck(options) {
-    const portableContextPath = options.portableContextPath
-        ?? portableContextPathForPreparation(options.sourcePath, options.preparationConfig.name);
-    const spec = buildTestSpecFromCompiledPreparationConfig({
-        compiledPath: portableContextPath,
-        targetType: "compiled",
+/**
+ * 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 target = createCompiledTestTarget(portableContextPath, options.preparationConfig.name, resolveMethodId(options.preparationConfig));
+    const sourceFolderPath = resolveConfiguredSourceFolderPath(options.sourcePath) ??
+        resolveSourcePreparationPath(options.sourcePath, options.preparationConfig);
+    const target = createSourceFilesTestTarget(sourceFolderPath);
     if (!target.eligible)
         return null;
-    const run = await runTargetTestsAuto(options.sourcePath, spec, [target], {
+    const run = await runTargetTestsAuto(sourceFolderPath, spec, [target], {
         executor: options.executor,
         preserveSandboxes: options.preserveSandboxes ?? "on-failure",
-        artifactRootPath: portableContextPath,
+        artifactRootPath: preparationTestsRoot(asPreparationDataDir(options.sourcePath), options.preparationConfig.name),
     });
     const result = run.results[0];
     if (!result)
         return null;
-    const compiledRunPath = saveTargetTestRun(portableContextPath, run);
     const preparationRunPath = writePreparationTargetRun({
         prepDataDir: options.sourcePath,
         preparationName: options.preparationConfig.name,
-        target: "compiled",
+        target: "source-files",
         generatedAt: run.generated_at,
         runId: normalizePreparationTestRunId(spec.id),
         runSuffix: options.runSuffix,
         payload: run,
     });
     return {
-        runPath: compiledRunPath,
-        displayRunPath: preparationRunPath,
+        runPath: preparationRunPath,
         target,
         result,
     };
 }
 export async function runReadinessChecksForExecutor(options) {
-    const sourceFilesPromise = options.mode === "source-files" || options.mode === "both"
-        ? runSavedSourceFilesCheck({
+    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,
         })
-        : Promise.resolve(null);
-    const compiledPromise = options.mode === "compiled" || options.mode === "both"
-        ? runSavedPortableContextCheck({
+        : null;
+    const sourceFilesOutcome = target === "source-files"
+        ? await runSavedSourceFilesCheck({
             sourcePath: options.sourcePath,
             preparationConfig: options.preparationConfig,
             executor: options.executor,
-            portableContextPath: options.portableContextPath,
             preserveSandboxes: options.preserveSandboxes,
             runSuffix: options.runSuffix,
         })
-        : Promise.resolve(null);
-    const [sourceFilesOutcome, compiledOutcome] = await Promise.all([sourceFilesPromise, compiledPromise]);
-    const modeSatisfied = (options.mode !== "source-files" || Boolean(sourceFilesOutcome)) &&
-        (options.mode !== "compiled" || Boolean(compiledOutcome)) &&
-        (options.mode !== "both" || (Boolean(sourceFilesOutcome) && Boolean(compiledOutcome)));
+        : null;
+    const modeSatisfied = Boolean(compiledOutcome) || Boolean(sourceFilesOutcome);
     const shouldSave = options.saveLatest !== false;
     const readinessRunPath = shouldSave && modeSatisfied
         ? saveReadinessCheckRun({
@@ -229,7 +243,6 @@ export async function runReadinessChecksForExecutor(options) {
             portableContextPath: options.portableContextPath,
             preparationName: options.preparationConfig.name,
             checksFingerprint: fingerprintReadinessChecks(options.preparationConfig.checks),
-            mode: options.mode,
             sourceFilesOutcome,
             compiledOutcome,
         })
@@ -241,7 +254,6 @@ export async function runReadinessChecksForExecutor(options) {
         sourcePath: options.sourcePath,
         preparationConfig: options.preparationConfig,
         portableContextPath: options.portableContextPath,
-        mode: options.mode,
         sourceFilesOutcome,
         compiledOutcome,
         readinessRunPath,

package/dist/packages/{testing/test-execution.d.ts → engine/verify/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/{testing/test-execution.js → engine/verify/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;
 }

package/dist/packages/{testing/test-paths.d.ts → engine/verify/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/{testing/test-paths.js → engine/verify/verify-paths.js}

@@ -1,7 +1,7 @@
 import { existsSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
-import { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, compiledInterfConfigPath, } from "../compiler/compiled-paths.js";
-import { asPreparationDataDir, preparationTestsSpecsRoot, } from "../contracts/lib/preparation-paths.js";
+import { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, compiledInterfConfigPath, } from "../compile/compiled-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) {

package/dist/packages/{testing/test-sandbox.d.ts → engine/verify/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/{testing/test-sandbox.js → engine/verify/verify-sandbox.js}

@@ -2,13 +2,13 @@ import { cpSync, mkdirSync, mkdtempSync, renameSync, rmSync, writeFileSync, } fr
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { refreshCompiledBootstrapGuidance } from "../agents/lib/compiled-bootstrap.js";
-import { readInterfConfig, resolveSourceInputPath } from "../project-model/interf.js";
+import { readInterfConfig, resolveSourceInputPath } from "../../project/interf.js";
 import { projectSourceFilesTestQueryShell } from "../agents/lib/shells.js";
-import { asPreparationDataDir, preparationPortableContextPath, } from "../contracts/lib/preparation-paths.js";
-import { saveCompiledInterfConfig } from "../project-model/source-config.js";
-import { buildCompiledSourceFiles } from "../compiler/source-files.js";
-import { refreshCompiledArtifacts } from "../compiler/state.js";
-import { testRootForCompiled, stageExecutionShellsRoot, targetTestSandboxesRootForCompiled, methodImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeLogsRoot, } from "../compiler/compiled-paths.js";
+import { asPreparationDataDir, preparationPortableContextPath, } from "../../contracts/lib/preparation-paths.js";
+import { saveCompiledInterfConfig } from "../../project/source-config.js";
+import { buildCompiledSourceFiles } from "../compile/source-files.js";
+import { refreshCompiledArtifacts } from "../compile/state.js";
+import { testRootForCompiled, stageExecutionShellsRoot, targetTestSandboxesRootForCompiled, methodImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeLogsRoot, } from "../compile/compiled-paths.js";
 function sanitizeCompiledArtifacts(compiledPath) {
     for (const absolutePath of [
         testRootForCompiled(compiledPath),

package/dist/packages/{testing/test-specs.d.ts → engine/verify/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/{testing/test-specs.js → engine/verify/verify-specs.js}

@@ -1,8 +1,8 @@
 import { existsSync, mkdirSync, readdirSync, writeFileSync, } from "node:fs";
 import { basename, extname, join } from "node:path";
-import { readJsonFileWithSchema } from "../shared/parse.js";
+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/{testing/test-targets.d.ts → engine/verify/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/{testing/test-targets.js → engine/verify/verify-targets.js}

@@ -1,6 +1,6 @@
-import { listPortableContextsForSourceFolder } from "../project-model/interf-detect.js";
-import { computeCompiledHealth } from "../compiler/state.js";
-import { DEFAULT_METHOD_ID, resolveMethodId } from "../methods/method-resolution.js";
+import { listPortableContextsForSourceFolder } from "../../project/interf-detect.js";
+import { computeCompiledHealth } from "../compile/state.js";
+import { DEFAULT_METHOD_ID, resolveMethodId } from "../../methods/method-resolution.js";
 function summarizeTargetSortKey(target) {
     return `${target.name}\u0000${target.method}`;
 }

package/dist/packages/{testing/test.d.ts → engine/verify/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/{testing/test.js → engine/verify/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";