@interf/compiler 0.9.1 → 0.9.4

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

@@ -3,9 +3,10 @@ import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { refreshCompiledBootstrapGuidance } from "../agents/lib/compiled-bootstrap.js";
 import { readInterfConfig, } from "./interf.js";
-import { seedCompiledWorkflowPackage } from "../workflow-package/interf-workflow-package.js";
+import { seedCompiledMethodPackage } from "../method-package/interf-method-package.js";
 import { readJsonFileWithSchema } from "../shared/parse.js";
-import { getCompiledWorkflow } from "../workflow-package/workflow-definitions.js";
+import { getCompiledMethod } from "../method-package/method-definitions.js";
+import { DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig, } from "../methods/method-resolution.js";
 import { SourceFolderConfigSchema, } from "./lib/schema.js";
 import { slugify } from "../shared/naming.js";
 import { assertPathWithinRoot, isPathWithinRoot } from "../shared/path-guards.js";
@@ -60,9 +61,7 @@ export function loadSourceFolderConfig(sourcePath) {
         return null;
     return readSourceFolderConfigFile(filePath);
 }
-export function methodIdForSourcePreparationConfig(preparationConfig) {
-    return preparationConfig?.method ?? preparationConfig?.workflow ?? null;
-}
+export { DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig } from "../methods/method-resolution.js";
 function normalizeSourcePreparationConfig(preparationConfig) {
     const method = methodIdForSourcePreparationConfig(preparationConfig);
     return {
@@ -71,15 +70,10 @@ function normalizeSourcePreparationConfig(preparationConfig) {
     };
 }
 export function listSourcePreparationConfigs(config) {
-    const explicitPreparations = config?.preparations ?? [];
-    const preparations = explicitPreparations.length > 0
-        ? explicitPreparations
-        : config?.datasets ?? [];
-    return preparations.map((preparation) => normalizeSourcePreparationConfig(preparation));
+    return (config?.preparations ?? []).map((preparation) => normalizeSourcePreparationConfig(preparation));
 }
-export const listSourceDatasetConfigs = listSourcePreparationConfigs;
-export function resolveDatasetCompileMaxAttempts(datasetConfig, override = null) {
-    const configured = override ?? datasetConfig.max_attempts ?? null;
+export function resolvePreparationCompileMaxAttempts(preparationConfig, override = null) {
+    const configured = override ?? preparationConfig.max_attempts ?? null;
     if (configured == null)
         return null;
     const normalized = Math.trunc(configured);
@@ -87,8 +81,8 @@ export function resolveDatasetCompileMaxAttempts(datasetConfig, override = null)
         return 1;
     return Math.min(5, normalized);
 }
-export function resolveDatasetCompileMaxLoops(datasetConfig, override = null) {
-    const configured = override ?? datasetConfig.max_loops ?? null;
+export function resolvePreparationCompileMaxLoops(preparationConfig, override = null) {
+    const configured = override ?? preparationConfig.max_loops ?? null;
     if (configured == null)
         return null;
     const normalized = Math.trunc(configured);
@@ -100,11 +94,9 @@ export function getDefaultSourcePreparationConfig(config) {
     const preparations = listSourcePreparationConfigs(config);
     return preparations[0] ?? null;
 }
-export const getDefaultSourceDatasetConfig = getDefaultSourcePreparationConfig;
 export function findSourcePreparationConfig(config, preparationName) {
     return listSourcePreparationConfigs(config).find((preparation) => preparation.name === preparationName) ?? null;
 }
-export const findSourceDatasetConfig = findSourcePreparationConfig;
 export function configuredSourceFolderPath(config) {
     return config?.source_folder?.path ?? null;
 }
@@ -113,10 +105,7 @@ export function resolveConfiguredSourceFolderPath(sourcePath, config = loadSourc
     return configuredPath ? resolve(sourcePath, configuredPath) : null;
 }
 function toWritableSourceProjectConfig(config) {
-    const explicitPreparations = config?.preparations ?? [];
-    const preparations = explicitPreparations.length > 0
-        ? explicitPreparations
-        : config?.datasets ?? [];
+    const preparations = config?.preparations ?? [];
     const sourceFolder = config?.source_folder;
     if (preparations.length > 0) {
         return {
@@ -135,13 +124,12 @@ function toWritableSourcePreparationConfig(preparation) {
         name: preparation.name,
         path: preparation.path,
         ...(preparation.about ? { about: preparation.about } : {}),
-        ...(method && method !== "interf" ? { method } : {}),
+        method: method ?? DEFAULT_METHOD_ID,
         ...(typeof preparation.max_attempts === "number" ? { max_attempts: preparation.max_attempts } : {}),
         ...(typeof preparation.max_loops === "number" ? { max_loops: preparation.max_loops } : {}),
         checks: preparation.checks,
     };
 }
-const toWritableSourceDatasetConfig = toWritableSourcePreparationConfig;
 export function saveSourceFolderConfig(sourcePath, config) {
     const existing = loadSourceFolderConfig(sourcePath);
     const mergedConfig = {
@@ -151,7 +139,7 @@ export function saveSourceFolderConfig(sourcePath, config) {
     mkdirSync(projectInterfRoot(sourcePath), { recursive: true });
     writeFileSync(sourceFolderConfigPath(sourcePath), JSON.stringify(toWritableSourceProjectConfig(mergedConfig), null, 2) + "\n");
 }
-export function appendSourceDatasetChecks(sourcePath, preparationName, checks) {
+export function appendSourcePreparationChecks(sourcePath, preparationName, checks) {
     const existing = loadSourceFolderConfig(sourcePath);
     const currentPreparation = findSourcePreparationConfig(existing, preparationName);
     const otherPreparations = listSourcePreparationConfigs(existing).filter((preparation) => preparation.name !== preparationName);
@@ -171,8 +159,7 @@ export function appendSourceDatasetChecks(sourcePath, preparationName, checks) {
         ],
     });
 }
-export const appendSourcePreparationChecks = appendSourceDatasetChecks;
-export function upsertSourceDatasetConfig(sourcePath, preparationConfig, options = {}) {
+export function upsertSourcePreparationConfig(sourcePath, preparationConfig, options = {}) {
     const existing = loadSourceFolderConfig(sourcePath);
     const preparations = listSourcePreparationConfigs(existing);
     const candidateNames = Array.from(new Set([preparationConfig.name, options.matchName].filter((value) => Boolean(value))));
@@ -187,24 +174,22 @@ export function upsertSourceDatasetConfig(sourcePath, preparationConfig, options
         preparations,
     });
 }
-export const upsertSourcePreparationConfig = upsertSourceDatasetConfig;
 export function compiledMaxAttempts(maxAttempts) {
     if (maxAttempts == null)
         return undefined;
-    return resolveDatasetCompileMaxAttempts({ max_attempts: maxAttempts }, null) ?? 1;
+    return resolvePreparationCompileMaxAttempts({ max_attempts: maxAttempts }, null) ?? 1;
 }
 export function compiledMaxLoops(maxLoops) {
     if (maxLoops == null)
         return undefined;
-    return resolveDatasetCompileMaxLoops({ max_loops: maxLoops }, null) ?? 1;
+    return resolvePreparationCompileMaxLoops({ max_loops: maxLoops }, null) ?? 1;
 }
-export function sourceDatasetConfigFromInterfConfig(config, preparationPath = `./${config.name}`) {
-    const method = config.method ?? config.workflow;
+export function sourcePreparationConfigFromInterfConfig(config, preparationPath = `./${config.name}`) {
     return {
         name: config.name,
         path: preparationPath,
         ...(config.about ? { about: config.about } : {}),
-        ...(method ? { method } : {}),
+        method: config.method,
         ...(typeof config.max_attempts === "number"
             ? { max_attempts: config.max_attempts }
             : {}),
@@ -214,7 +199,7 @@ export function sourceDatasetConfigFromInterfConfig(config, preparationPath = `.
         checks: config.checks ?? [],
     };
 }
-export function loadCompiledDatasetConfig(compiledPath) {
+export function loadCompiledPreparationConfig(compiledPath) {
     const config = readInterfConfig(compiledPath);
     if (!config)
         return null;
@@ -225,11 +210,7 @@ export function loadCompiledDatasetConfig(compiledPath) {
         : `./${config.name}`;
     const sourceBinding = typeof config.source?.preparation_path === "string" && config.source.preparation_path.length > 0
         ? config.source.preparation_path
-        : typeof config.source?.source_folder_path === "string" && config.source.source_folder_path.length > 0
-            ? config.source.source_folder_path
-            : typeof config.source?.dataset_path === "string" && config.source.dataset_path.length > 0
-                ? config.source.dataset_path
-                : null;
+        : null;
     const preparationPath = sourceBinding
         ? (() => {
             const sourceAbsolutePath = resolve(compiledPath, sourceBinding);
@@ -239,19 +220,21 @@ export function loadCompiledDatasetConfig(compiledPath) {
             return relative(projectPath, sourceAbsolutePath).split(sep).join("/") || defaultPreparationPath;
         })()
         : defaultPreparationPath;
-    return sourceDatasetConfigFromInterfConfig(config, preparationPath);
+    return sourcePreparationConfigFromInterfConfig(config, preparationPath);
 }
 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) {
+export function syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath, preparationConfig) {
     const current = readInterfConfig(compiledPath);
     const projectPath = resolveSourceControlPathForCompiled(compiledPath);
-    const datasetAbsolutePath = resolveSourceDatasetPath(projectPath, datasetConfig);
-    const datasetRelativePath = relative(compiledPath, datasetAbsolutePath).split(sep).join("/") || ".";
-    const methodId = methodIdForSourcePreparationConfig(datasetConfig) ?? current?.method ?? current?.workflow ?? "interf";
+    const preparationAbsolutePath = resolveSourcePreparationPath(projectPath, preparationConfig);
+    const preparationRelativePath = relative(compiledPath, preparationAbsolutePath).split(sep).join("/") || ".";
+    const methodId = methodIdForSourcePreparationConfig(preparationConfig)
+        ?? methodIdForSourcePreparationConfig(current)
+        ?? DEFAULT_METHOD_ID;
     const methodChanged = current?.method !== undefined && current.method !== methodId;
     const methodOrigin = methodChanged || !current?.method_origin
         ? {
@@ -259,7 +242,7 @@ export function syncCompiledInterfConfigFromSourceDatasetConfig(compiledPath, da
             local_draft: false,
         }
         : current.method_origin;
-    const { type: _ignoredType, name: _ignoredName, about: _ignoredAbout, method: _ignoredMethod, workflow: _ignoredWorkflow, max_attempts: _ignoredMaxAttempts, max_loops: _ignoredMaxLoops, checks: _ignoredChecks, method_origin: _ignoredMethodOrigin, workflow_origin: _ignoredWorkflowOrigin, source: _ignoredSource, ...passthrough } = current ?? {};
+    const { type: _ignoredType, name: _ignoredName, about: _ignoredAbout, method: _ignoredMethod, max_attempts: _ignoredMaxAttempts, max_loops: _ignoredMaxLoops, checks: _ignoredChecks, method_origin: _ignoredMethodOrigin, source: _ignoredSource, ...passthrough } = current ?? {};
     const nextConfig = {
         ...passthrough,
         ...(!current ? {
@@ -269,31 +252,31 @@ export function syncCompiledInterfConfigFromSourceDatasetConfig(compiledPath, da
             },
         } : {}),
         type: "compiled",
-        name: datasetConfig.name,
-        ...(datasetConfig.about ? { about: datasetConfig.about } : {}),
+        name: preparationConfig.name,
+        ...(preparationConfig.about ? { about: preparationConfig.about } : {}),
         method: methodId,
-        ...(typeof datasetConfig.max_attempts === "number"
-            ? { max_attempts: datasetConfig.max_attempts }
+        ...(typeof preparationConfig.max_attempts === "number"
+            ? { max_attempts: preparationConfig.max_attempts }
             : {}),
-        ...(typeof datasetConfig.max_loops === "number"
-            ? { max_loops: datasetConfig.max_loops }
+        ...(typeof preparationConfig.max_loops === "number"
+            ? { max_loops: preparationConfig.max_loops }
             : {}),
-        checks: datasetConfig.checks,
+        checks: preparationConfig.checks,
         method_origin: methodOrigin,
         source: {
             path: current?.source?.path ?? "./raw",
             control_path: defaultControlPathForCompiled(compiledPath),
-            preparation_path: datasetRelativePath,
+            preparation_path: preparationRelativePath,
         },
     };
     const saved = saveCompiledInterfConfig(compiledPath, nextConfig);
     if (methodChanged) {
         const sourcePath = projectPath;
-        const selectedWorkflow = getCompiledWorkflow(methodId, { sourcePath });
-        seedCompiledWorkflowPackage({
+        const selectedMethod = getCompiledMethod(methodId, { sourcePath });
+        seedCompiledMethodPackage({
             compiledPath,
             sourcePath,
-            workflowId: selectedWorkflow.id,
+            methodId: selectedMethod.id,
         });
     }
     refreshCompiledBootstrapGuidance(compiledPath);
@@ -340,7 +323,7 @@ export function buildTestSpecFromSourceFolderConfig(options) {
         defaultDescription: `Derived from saved Preparation checks in ${SOURCE_FOLDER_CONFIG_PATH}`,
     });
 }
-export function buildTestSpecFromCompiledDatasetConfig(options) {
+export function buildTestSpecFromCompiledPreparationConfig(options) {
     const { compiledPath, targetType = "compiled" } = options;
     const config = readInterfConfig(compiledPath);
     const configPath = compiledInterfConfigPath(compiledPath);
@@ -354,15 +337,14 @@ export function buildTestSpecFromCompiledDatasetConfig(options) {
         filePath: targetType === "raw"
             ? `${configPath}#checks:file-as-is`
             : `${configPath}#checks:compiled`,
-        defaultDescription: "Derived from checks in the compiled context config.",
+        defaultDescription: "Derived from checks in the portable context config.",
     });
 }
-export function resolveSourceDatasetPath(projectPath, datasetConfig) {
-    const configuredPath = datasetConfig.path.trim();
+export function resolveSourcePreparationPath(projectPath, preparationConfig) {
+    const configuredPath = preparationConfig.path.trim();
     const resolvedPath = resolve(projectPath, configuredPath);
     if (isAbsolute(configuredPath)) {
         return resolvedPath;
     }
     return assertPathWithinRoot(projectPath, resolvedPath, "Source folder path");
 }
-export const resolveSourcePreparationPath = resolveSourceDatasetPath;

package/dist/packages/project-model/source-folders.d.ts

@@ -1,11 +1,11 @@
 export declare function listVisibleSourceFolders(projectPath: string): string[];
-export declare function isReservedSourceDatasetPath(relativePath: string): boolean;
-export declare function normalizeSourceDatasetPathForConfig(projectPath: string, value: string): string;
-export declare function defaultDatasetNameForPath(datasetPath: string): string;
+export declare function isReservedSourcePreparationPath(relativePath: string): boolean;
+export declare function normalizeSourcePreparationPathForConfig(projectPath: string, value: string): string;
+export declare function defaultPreparationNameForPath(sourceFolderPath: string): string;
 export declare function findSingleSourceFolderCandidate(projectPath: string): string | null;
 export declare function listSourceFolderChoices(projectPath?: string): Array<{
     value: string;
     label: string;
     hint: string;
 }>;
-export declare function defaultSourceDatasetPathForPrompt(name: string, introStyle: "first" | "additional" | "edit", projectPath?: string): string;
+export declare function defaultSourcePreparationPathForPrompt(name: string, introStyle: "first" | "additional" | "edit", projectPath?: string): string;

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

@@ -1,9 +1,9 @@
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { isAbsolute, join, relative, sep } from "node:path";
 import { slugify } from "../shared/naming.js";
-import { resolveSourceDatasetPath } from "./source-config.js";
+import { resolveSourcePreparationPath } from "./source-config.js";
 import { isPathWithinRoot } from "../shared/path-guards.js";
-const DEFAULT_DATASET_NAME = "dataset1";
+const DEFAULT_PREPARATION_NAME = "default";
 const IGNORED_SOURCE_FOLDER_ENTRIES = new Set([
     ".DS_Store",
     ".git",
@@ -35,16 +35,16 @@ export function listVisibleSourceFolders(projectPath) {
     }
     return visibleDirectories.sort((left, right) => left.localeCompare(right));
 }
-export function isReservedSourceDatasetPath(relativePath) {
+export function isReservedSourcePreparationPath(relativePath) {
     const normalized = relativePath.replace(/\\/g, "/").replace(/^\.\/+/, "");
     return normalized === "interf" ||
         normalized.startsWith("interf/") ||
         normalized === ".interf" ||
         normalized.startsWith(".interf/");
 }
-export function normalizeSourceDatasetPathForConfig(projectPath, value) {
+export function normalizeSourcePreparationPathForConfig(projectPath, value) {
     const trimmedValue = value.trim();
-    const resolvedPath = resolveSourceDatasetPath(projectPath, { path: trimmedValue });
+    const resolvedPath = resolveSourcePreparationPath(projectPath, { path: trimmedValue });
     const relativePath = relative(projectPath, resolvedPath).split(sep).join("/") || ".";
     if (relativePath === ".") {
         throw new Error("Pick a Source Folder, not the Interf Workspace itself.");
@@ -58,7 +58,7 @@ export function normalizeSourceDatasetPathForConfig(projectPath, value) {
         }
         return resolvedPath;
     }
-    if (isReservedSourceDatasetPath(relativePath)) {
+    if (isReservedSourcePreparationPath(relativePath)) {
         throw new Error("Pick an existing source folder, not `interf/` or `.interf/`.");
     }
     if (!existsSync(resolvedPath)) {
@@ -69,13 +69,13 @@ export function normalizeSourceDatasetPathForConfig(projectPath, value) {
     }
     return relativePath.startsWith("./") ? relativePath : `./${relativePath}`;
 }
-export function defaultDatasetNameForPath(datasetPath) {
-    const segments = datasetPath
+export function defaultPreparationNameForPath(sourceFolderPath) {
+    const segments = sourceFolderPath
         .replace(/\\/g, "/")
         .replace(/\/+$/g, "")
         .split("/")
         .filter((segment) => segment.length > 0 && segment !== ".");
-    return slugify(segments[segments.length - 1] ?? "") || DEFAULT_DATASET_NAME;
+    return slugify(segments[segments.length - 1] ?? "") || DEFAULT_PREPARATION_NAME;
 }
 export function findSingleSourceFolderCandidate(projectPath) {
     const visibleDirectories = listVisibleSourceFolders(projectPath);
@@ -91,7 +91,7 @@ export function listSourceFolderChoices(projectPath = process.cwd()) {
         hint: `Use ./${entry} as the source folder`,
     }));
 }
-export function defaultSourceDatasetPathForPrompt(name, introStyle, projectPath = process.cwd()) {
+export function defaultSourcePreparationPathForPrompt(name, introStyle, projectPath = process.cwd()) {
     const namedFolderPath = join(projectPath, name);
     if (existsSync(namedFolderPath)) {
         try {

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

@@ -1,13 +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 readinessCheckRun from "./readiness-check-run.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 { TestCase, TestCaseExpect, TestCheckResult, TestCaseResult, TestSpec, TestTargetResult, TestTargetRun, ReadinessCheckRun, 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

@@ -1,9 +1,9 @@
 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 readinessCheckRun from "./readiness-check-run.js";
 export * as sandbox from "./test-sandbox.js";
 export * as specs from "./test-specs.js";
 export * as targets from "./test-targets.js";

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { type TestCaseExpect, type TestTargetType } from "../../compiler/lib/schema.js";
+import { type TestCaseExpect, type TestTargetType } from "../../contracts/lib/schema.js";
 export declare const TestCaseSchema: z.ZodObject<{
     id: z.ZodString;
     question: z.ZodString;
@@ -65,7 +65,7 @@ export declare const TestTargetResultSchema: z.ZodObject<{
         }>;
         name: z.ZodString;
         path: z.ZodString;
-        workflow: z.ZodString;
+        method: z.ZodString;
     }, z.core.$strip>;
     sandbox_path: z.ZodOptional<z.ZodString>;
     ok: z.ZodBoolean;
@@ -143,7 +143,7 @@ export declare const TestTargetRunSchema: z.ZodObject<{
             }>;
             name: z.ZodString;
             path: z.ZodString;
-            workflow: z.ZodString;
+            method: z.ZodString;
         }, z.core.$strip>;
         sandbox_path: z.ZodOptional<z.ZodString>;
         ok: z.ZodBoolean;
@@ -189,11 +189,11 @@ export declare const TestRunTargetSummarySchema: z.ZodObject<{
         }>;
         name: z.ZodString;
         path: z.ZodString;
-        workflow: z.ZodString;
+        method: z.ZodString;
     }, z.core.$strip>;
 }, z.core.$strip>;
-export declare const TestRunComparisonSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"interf-test-run">;
+export declare const ReadinessCheckRunSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"interf-readiness-check-run">;
     version: z.ZodLiteral<1>;
     generated_at: z.ZodString;
     mode: z.ZodEnum<{
@@ -203,9 +203,9 @@ export declare const TestRunComparisonSchema: z.ZodObject<{
     }>;
     source_path: z.ZodString;
     checks_fingerprint: z.ZodOptional<z.ZodString>;
-    dataset: z.ZodObject<{
+    preparation: z.ZodObject<{
         name: z.ZodString;
-        compiled_path: z.ZodNullable<z.ZodString>;
+        portable_context_path: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>;
     raw: z.ZodNullable<z.ZodObject<{
         label: z.ZodString;
@@ -222,7 +222,7 @@ export declare const TestRunComparisonSchema: z.ZodObject<{
             }>;
             name: z.ZodString;
             path: z.ZodString;
-            workflow: z.ZodString;
+            method: z.ZodString;
         }, z.core.$strip>;
     }, z.core.$strip>>;
     compiled: z.ZodNullable<z.ZodObject<{
@@ -240,7 +240,7 @@ export declare const TestRunComparisonSchema: z.ZodObject<{
             }>;
             name: z.ZodString;
             path: z.ZodString;
-            workflow: z.ZodString;
+            method: z.ZodString;
         }, z.core.$strip>;
     }, z.core.$strip>>;
     summary: z.ZodObject<{
@@ -258,4 +258,4 @@ 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>;
+export type ReadinessCheckRun = z.infer<typeof ReadinessCheckRunSchema>;

package/dist/packages/testing/lib/schema.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
-import { RuntimeExecutorInfoSchema, TestCaseExpectSchema, TestTargetTypeSchema, } from "../../compiler/lib/schema.js";
-import { DatasetNameSchema } from "../../project-model/lib/schema.js";
+import { RuntimeExecutorInfoSchema, TestCaseExpectSchema, TestTargetTypeSchema, PreparationNameSchema, } from "../../contracts/lib/schema.js";
 const TestCaseCoreSchema = z.object({
     id: z.string().regex(/^[a-z0-9][a-z0-9-]{0,79}$/),
     question: z.string().min(1),
@@ -47,7 +46,7 @@ export const TestTargetResultSchema = z.object({
         type: TestTargetTypeSchema,
         name: z.string(),
         path: z.string(),
-        workflow: z.string(),
+        method: z.string(),
     }),
     sandbox_path: z.string().optional(),
     ok: z.boolean(),
@@ -95,19 +94,19 @@ export const TestRunTargetSummarySchema = z.object({
         type: TestTargetTypeSchema,
         name: z.string(),
         path: z.string(),
-        workflow: z.string(),
+        method: z.string(),
     }),
 });
-export const TestRunComparisonSchema = z.object({
-    kind: z.literal("interf-test-run"),
+export const ReadinessCheckRunSchema = z.object({
+    kind: z.literal("interf-readiness-check-run"),
     version: z.literal(1),
     generated_at: z.string(),
     mode: TestRunModeSchema,
     source_path: z.string(),
     checks_fingerprint: z.string().min(1).optional(),
-    dataset: z.object({
-        name: DatasetNameSchema,
-        compiled_path: z.string().nullable(),
+    preparation: z.object({
+        name: PreparationNameSchema,
+        portable_context_path: z.string().nullable(),
     }),
     raw: TestRunTargetSummarySchema.nullable(),
     compiled: TestRunTargetSummarySchema.nullable(),

package/dist/packages/testing/readiness-check-run.d.ts

@@ -0,0 +1,67 @@
+import type { MethodExecutor } from "../agents/lib/executors.js";
+import type { SourcePreparationConfig } from "../project-model/lib/schema.js";
+import { type TestTargetCandidate, type TestTargetResult } from "./test.js";
+import type { TestSandboxRetentionMode } from "./test-sandbox.js";
+import { type ReadinessCheckRun, type TestRunMode } from "./lib/schema.js";
+export interface SavedReadinessCheckOutcome {
+    runPath: string;
+    displayRunPath?: string;
+    target: TestTargetCandidate;
+    result: TestTargetResult;
+}
+export interface ReadinessCheckRunResult {
+    sourcePath: string;
+    preparationConfig: SourcePreparationConfig;
+    portableContextPath: string | null;
+    mode: TestRunMode;
+    rawOutcome: SavedReadinessCheckOutcome | null;
+    compiledOutcome: SavedReadinessCheckOutcome | null;
+    comparisonRunPath: string | null;
+    comparison: ReadinessCheckRun | null;
+}
+export declare function readinessPassRate(outcome: SavedReadinessCheckOutcome): number;
+export declare function readSavedReadinessCheckRun(projectPath: 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: {
+    projectPath: string;
+    preparationName: string;
+    checks: SourcePreparationConfig["checks"];
+}): {
+    comparison: ReadinessCheckRun | null;
+    stale: boolean;
+};
+export declare function saveReadinessCheckRun(options: {
+    sourcePath: string;
+    portableContextPath: string | null;
+    preparationName: string;
+    checksFingerprint: string;
+    mode: TestRunMode;
+    rawOutcome: SavedReadinessCheckOutcome | null;
+    compiledOutcome: SavedReadinessCheckOutcome | null;
+}): string;
+export declare function runSavedSourceFilesCheck(options: {
+    sourcePath: string;
+    preparationConfig: SourcePreparationConfig;
+    executor?: MethodExecutor | null;
+    preserveSandboxes?: TestSandboxRetentionMode;
+    runSuffix?: string | null;
+}): Promise<SavedReadinessCheckOutcome | null>;
+export declare function runSavedPortableContextCheck(options: {
+    sourcePath: string;
+    preparationConfig: SourcePreparationConfig;
+    executor?: MethodExecutor | null;
+    portableContextPath?: string | null;
+    preserveSandboxes?: TestSandboxRetentionMode;
+    runSuffix?: string | null;
+}): Promise<SavedReadinessCheckOutcome | null>;
+export declare function runReadinessChecksForExecutor(options: {
+    sourcePath: string;
+    preparationConfig: SourcePreparationConfig;
+    portableContextPath: string | null;
+    mode: TestRunMode;
+    executor?: MethodExecutor | null;
+    preserveSandboxes?: TestSandboxRetentionMode;
+    runSuffix?: string | null;
+    saveLatest?: boolean;
+}): Promise<ReadinessCheckRunResult>;