@interf/compiler 0.7.3 → 0.9.3

package/dist/packages/project-model/interf-scaffold.d.ts

@@ -1,3 +1,3 @@
-export declare function ensurePortableContextScaffold(sourcePath: string, datasetName: string, workflowId?: string): string;
-export declare function createCompiled(name: string, sourcePath: string, workflowId?: string, about?: string, datasetPath?: string): string;
+export declare function ensurePortableContextScaffold(sourcePath: string, preparationName: string, methodId?: string): string;
+export declare function createCompiled(name: string, sourcePath: string, methodId?: string, about?: string, sourceFolderPath?: string): string;
 export declare function defaultCompiledNameForSource(sourcePath: string): string;

package/dist/packages/project-model/interf-scaffold.js

@@ -1,16 +1,17 @@
 import { mkdirSync, existsSync, writeFileSync, } from "node:fs";
 import { basename, join, relative, sep } from "node:path";
-import { getCompiledWorkflow } from "../workflow-package/workflow-definitions.js";
-import { loadWorkflowDefinitionFromDir, seedLocalDefaultWorkflow } from "../workflow-package/local-workflows.js";
+import { getCompiledMethod } from "../method-package/method-definitions.js";
+import { loadMethodDefinitionFromDir, seedLocalDefaultMethod } from "../method-package/local-methods.js";
 import { initializeCompiledRuntimeState, } from "../compiler/state.js";
 import { refreshCompiledBootstrapGuidance } from "../agents/lib/compiled-bootstrap.js";
 import { syncCompiledRawSnapshot } from "../compiler/raw-snapshot.js";
 import { assertCompiledContainer, assertCompiledName, } from "./interf-detect.js";
-import { seedCompiledWorkflowPackage } from "../workflow-package/interf-workflow-package.js";
-import { compiledCompiledPathForDataset } from "./project-paths.js";
+import { seedCompiledMethodPackage } from "../method-package/interf-method-package.js";
+import { portableContextPath } from "./project-paths.js";
 import { ensureCompiledZoneTargets, readCompiledSchemaFile } from "../compiler/compiled-schema.js";
-import { findSourceDatasetConfig, listSourceDatasetConfigs, loadSourceFolderConfig, resolveSourceDatasetPath, saveCompiledInterfConfig, } from "./source-config.js";
-import { defaultControlPathForCompiled, testRootForCompiled, workflowPackagePathForCompiled } from "../compiler/compiled-paths.js";
+import { findSourcePreparationConfig, listSourcePreparationConfigs, loadSourceFolderConfig, methodIdForSourcePreparationConfig, resolveSourcePreparationPath, saveCompiledInterfConfig, } from "./source-config.js";
+import { defaultControlPathForCompiled, testRootForCompiled, methodPackagePathForCompiled } from "../compiler/compiled-paths.js";
+import { DEFAULT_METHOD_ID } from "../methods/method-resolution.js";
 const DEFAULT_INTERFIGNORE = [
     ".claude/",
     ".codex/",
@@ -32,7 +33,7 @@ function renderUncompiledCompiledFile(compiledName, relativePath, about) {
     ].join("\n");
 }
 function compiledGitignoreEntries(compiledPath) {
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
+    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
     const zoneEntries = (schema?.zones ?? [])
         .filter((zone) => zone.kind !== "runtime")
         .map((zone) => zone.kind === "file" ? zone.path : `${zone.path}/`);
@@ -48,9 +49,9 @@ function compiledGitignoreEntries(compiledPath) {
     ];
 }
 function scaffoldCompiledOutputs(compiledPath, compiledName, about) {
-    const schema = readCompiledSchemaFile(workflowPackagePathForCompiled(compiledPath));
+    const schema = readCompiledSchemaFile(methodPackagePathForCompiled(compiledPath));
     if (!schema) {
-        throw new Error(`Missing workflow schema at ${workflowPackagePathForCompiled(compiledPath)}.`);
+        throw new Error(`Missing Method schema at ${methodPackagePathForCompiled(compiledPath)}.`);
     }
     ensureCompiledZoneTargets(compiledPath, schema);
     for (const zone of schema.zones) {
@@ -62,25 +63,25 @@ function scaffoldCompiledOutputs(compiledPath, compiledName, about) {
         writeFileSync(targetPath, renderUncompiledCompiledFile(compiledName, zone.path, about));
     }
 }
-function localWorkflowMatches(compiledPath, workflowId) {
-    const localWorkflow = loadWorkflowDefinitionFromDir(workflowPackagePathForCompiled(compiledPath));
-    return localWorkflow?.id === workflowId;
+function localMethodMatches(compiledPath, methodId) {
+    const localMethod = loadMethodDefinitionFromDir(methodPackagePathForCompiled(compiledPath));
+    return localMethod?.id === methodId;
 }
-export function ensurePortableContextScaffold(sourcePath, datasetName, workflowId = "interf") {
-    assertCompiledName(datasetName, "Portable context");
+export function ensurePortableContextScaffold(sourcePath, preparationName, methodId = DEFAULT_METHOD_ID) {
+    assertCompiledName(preparationName, "Portable context");
     assertCompiledContainer(sourcePath);
-    const compiledPath = compiledCompiledPathForDataset(sourcePath, datasetName);
+    const compiledPath = portableContextPath(sourcePath, preparationName);
     mkdirSync(compiledPath, { recursive: true });
     mkdirSync(testRootForCompiled(compiledPath), { recursive: true });
-    if (workflowId === "interf-default") {
-        seedLocalDefaultWorkflow({ sourcePath });
+    if (methodId === "interf-default") {
+        seedLocalDefaultMethod({ sourcePath });
     }
-    const selectedWorkflow = getCompiledWorkflow(workflowId, { sourcePath });
-    if (!localWorkflowMatches(compiledPath, selectedWorkflow.id)) {
-        seedCompiledWorkflowPackage({
+    const selectedMethod = getCompiledMethod(methodId, { sourcePath });
+    if (!localMethodMatches(compiledPath, selectedMethod.id)) {
+        seedCompiledMethodPackage({
             compiledPath,
             sourcePath,
-            workflowId: selectedWorkflow.id,
+            methodId: selectedMethod.id,
         });
     }
     if (!existsSync(join(compiledPath, ".gitignore"))) {
@@ -88,30 +89,31 @@ export function ensurePortableContextScaffold(sourcePath, datasetName, workflowI
     }
     return compiledPath;
 }
-export function createCompiled(name, sourcePath, workflowId = "interf", about, datasetPath) {
+export function createCompiled(name, sourcePath, methodId = DEFAULT_METHOD_ID, about, sourceFolderPath) {
     assertCompiledName(name, "Portable context");
-    const savedCompiled = findSourceDatasetConfig(loadSourceFolderConfig(sourcePath), name);
-    const selectedWorkflow = getCompiledWorkflow(workflowId, { sourcePath });
-    const compiledPath = ensurePortableContextScaffold(sourcePath, name, selectedWorkflow.id);
+    const savedCompiled = findSourcePreparationConfig(loadSourceFolderConfig(sourcePath), name);
+    const effectiveMethodId = methodIdForSourcePreparationConfig(savedCompiled) ?? methodId;
+    const selectedMethod = getCompiledMethod(effectiveMethodId, { sourcePath });
+    const compiledPath = ensurePortableContextScaffold(sourcePath, name, selectedMethod.id);
     const resolvedAbout = about ?? savedCompiled?.about;
-    const resolvedDatasetPath = (() => {
+    const resolvedSourceFolderPath = (() => {
         if (savedCompiled) {
-            return resolveSourceDatasetPath(sourcePath, savedCompiled);
+            return resolveSourcePreparationPath(sourcePath, savedCompiled);
         }
-        if (datasetPath) {
-            return datasetPath;
+        if (sourceFolderPath) {
+            return sourceFolderPath;
         }
-        const configuredDatasets = listSourceDatasetConfigs(loadSourceFolderConfig(sourcePath));
-        if (configuredDatasets.length === 1) {
-            return resolveSourceDatasetPath(sourcePath, configuredDatasets[0]);
+        const configuredPreparations = listSourcePreparationConfigs(loadSourceFolderConfig(sourcePath));
+        if (configuredPreparations.length === 1) {
+            return resolveSourcePreparationPath(sourcePath, configuredPreparations[0]);
         }
-        throw new Error("Cannot infer the source folder for this portable context. Select a source folder first or pass an explicit dataset path.");
+        throw new Error("Cannot infer the source folder for this portable context. Select a source folder first or pass an explicit source folder path.");
     })();
     saveCompiledInterfConfig(compiledPath, {
         type: "compiled",
         name,
         ...(resolvedAbout ? { about: resolvedAbout } : {}),
-        workflow: selectedWorkflow.id,
+        method: selectedMethod.id,
         ...(typeof savedCompiled?.max_attempts === "number"
             ? { max_attempts: savedCompiled.max_attempts }
             : {}),
@@ -119,18 +121,18 @@ export function createCompiled(name, sourcePath, workflowId = "interf", about, d
             ? { max_loops: savedCompiled.max_loops }
             : {}),
         checks: savedCompiled?.checks ?? [],
-        workflow_origin: {
-            selected: selectedWorkflow.id,
+        method_origin: {
+            selected: selectedMethod.id,
             local_draft: false,
         },
         source: {
             path: "./raw",
             control_path: defaultControlPathForCompiled(compiledPath),
-            dataset_path: relative(compiledPath, resolvedDatasetPath).split(sep).join("/") || ".",
+            preparation_path: relative(compiledPath, resolvedSourceFolderPath).split(sep).join("/") || ".",
         },
     });
     mkdirSync(join(compiledPath, "raw"), { recursive: true });
-    syncCompiledRawSnapshot(compiledPath, resolvedDatasetPath);
+    syncCompiledRawSnapshot(compiledPath, resolvedSourceFolderPath);
     writeFileSync(join(compiledPath, ".interfignore"), DEFAULT_INTERFIGNORE);
     scaffoldCompiledOutputs(compiledPath, name, about);
     refreshCompiledBootstrapGuidance(compiledPath);

package/dist/packages/project-model/interf.d.ts

@@ -1,5 +1,4 @@
-export { INTERF_CONTAINER_NAME, WORKFLOW_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, WORKFLOW_PACKAGE_DIR, readInterfConfig, detectInterf, resolveCompiled, resolveSourceFolderPath, resolveSourceControlPath, resolveSourceInputPath, listCompiledDatasetsForSourceFolder, hasSourceFolderInput, assertCompiledContainer, assertWritableTargetDir, assertCompiledName, } from "./interf-detect.js";
+export { INTERF_CONTAINER_NAME, METHOD_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, METHOD_PACKAGE_DIR, readInterfConfig, detectInterf, resolveCompiled, resolveSourceFolderPath, resolveSourceControlPath, resolveSourceInputPath, listPortableContextsForSourceFolder, hasSourceFolderInput, assertCompiledContainer, assertWritableTargetDir, assertCompiledName, } from "./interf-detect.js";
 export type { InterfConfig, ResolvedCompiled } from "./interf-detect.js";
-export { ensureCompiledRawBinding, resolveCompiledRawPath, syncCompiledRawSnapshot, } from "./compiled-raw.js";
 export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "./interf-bootstrap.js";
 export { createCompiled, defaultCompiledNameForSource, ensurePortableContextScaffold, } from "./interf-scaffold.js";

package/dist/packages/project-model/interf.js

@@ -1,4 +1,3 @@
-export { INTERF_CONTAINER_NAME, WORKFLOW_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, WORKFLOW_PACKAGE_DIR, readInterfConfig, detectInterf, resolveCompiled, resolveSourceFolderPath, resolveSourceControlPath, resolveSourceInputPath, listCompiledDatasetsForSourceFolder, hasSourceFolderInput, assertCompiledContainer, assertWritableTargetDir, assertCompiledName, } from "./interf-detect.js";
-export { ensureCompiledRawBinding, resolveCompiledRawPath, syncCompiledRawSnapshot, } from "./compiled-raw.js";
+export { INTERF_CONTAINER_NAME, METHOD_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, METHOD_PACKAGE_DIR, readInterfConfig, detectInterf, resolveCompiled, resolveSourceFolderPath, resolveSourceControlPath, resolveSourceInputPath, listPortableContextsForSourceFolder, hasSourceFolderInput, assertCompiledContainer, assertWritableTargetDir, assertCompiledName, } from "./interf-detect.js";
 export { refreshCompiledBootstrapGuidance, renderClaudeBootstrap, } from "./interf-bootstrap.js";
 export { createCompiled, defaultCompiledNameForSource, ensurePortableContextScaffold, } from "./interf-scaffold.js";

package/dist/packages/project-model/lib/schema.d.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
-export declare const DatasetNameSchema: z.ZodString;
-export declare const SourceTruthCheckSchema: z.ZodObject<{
+import { MethodIdSchema, PreparationNameSchema } from "../../contracts/lib/schema.js";
+export { MethodIdSchema, PreparationNameSchema, } from "../../contracts/lib/schema.js";
+export declare const SourceReadinessCheckSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     question: z.ZodString;
     answer: z.ZodOptional<z.ZodString>;
@@ -13,12 +14,12 @@ export declare const SourceTruthCheckSchema: z.ZodObject<{
     }, z.core.$strip>>;
     strictness: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
-export declare const SourceDatasetConfigSchema: z.ZodObject<{
+export declare const SourcePreparationConfigSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
     name: z.ZodString;
     path: z.ZodString;
     about: z.ZodOptional<z.ZodString>;
-    workflow: z.ZodOptional<z.ZodString>;
+    method: z.ZodOptional<z.ZodString>;
     max_attempts: z.ZodOptional<z.ZodNumber>;
     max_loops: z.ZodOptional<z.ZodNumber>;
     checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -35,11 +36,14 @@ export declare const SourceDatasetConfigSchema: z.ZodObject<{
         strictness: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
 }, z.core.$strict>;
+export declare const SourceFolderBindingSchema: z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strict>;
 export declare const CompiledInterfConfigSchema: z.ZodObject<{
     type: z.ZodLiteral<"compiled">;
     name: z.ZodString;
     about: z.ZodOptional<z.ZodString>;
-    workflow: z.ZodString;
+    method: z.ZodString;
     max_attempts: z.ZodOptional<z.ZodNumber>;
     max_loops: z.ZodOptional<z.ZodNumber>;
     checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -55,21 +59,21 @@ export declare const CompiledInterfConfigSchema: z.ZodObject<{
         }, z.core.$strip>>;
         strictness: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
-    workflow_origin: z.ZodOptional<z.ZodObject<{
+    method_origin: z.ZodOptional<z.ZodObject<{
         selected: z.ZodString;
         local_draft: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
     source: z.ZodObject<{
         path: z.ZodString;
         control_path: z.ZodOptional<z.ZodString>;
-        dataset_path: z.ZodString;
+        preparation_path: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$loose>;
 export declare const InterfConfigSchema: z.ZodObject<{
     type: z.ZodLiteral<"compiled">;
     name: z.ZodString;
     about: z.ZodOptional<z.ZodString>;
-    workflow: z.ZodString;
+    method: z.ZodString;
     max_attempts: z.ZodOptional<z.ZodNumber>;
     max_loops: z.ZodOptional<z.ZodNumber>;
     checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -85,23 +89,26 @@ export declare const InterfConfigSchema: z.ZodObject<{
         }, z.core.$strip>>;
         strictness: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>>;
-    workflow_origin: z.ZodOptional<z.ZodObject<{
+    method_origin: z.ZodOptional<z.ZodObject<{
         selected: z.ZodString;
         local_draft: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
     source: z.ZodObject<{
         path: z.ZodString;
         control_path: z.ZodOptional<z.ZodString>;
-        dataset_path: z.ZodString;
+        preparation_path: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$loose>;
 export declare const SourceFolderConfigSchema: z.ZodObject<{
-    datasets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    source_folder: z.ZodOptional<z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>>;
+    preparations: z.ZodDefault<z.ZodArray<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         name: z.ZodString;
         path: z.ZodString;
         about: z.ZodOptional<z.ZodString>;
-        workflow: z.ZodOptional<z.ZodString>;
+        method: z.ZodOptional<z.ZodString>;
         max_attempts: z.ZodOptional<z.ZodNumber>;
         max_loops: z.ZodOptional<z.ZodNumber>;
         checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -119,7 +126,10 @@ export declare const SourceFolderConfigSchema: z.ZodObject<{
         }, z.core.$strict>>>;
     }, z.core.$strict>>>;
 }, z.core.$strict>;
-export type SourceTruthCheck = z.infer<typeof SourceTruthCheckSchema>;
-export type SourceDatasetConfig = z.infer<typeof SourceDatasetConfigSchema>;
+export type SourceFolderBinding = z.infer<typeof SourceFolderBindingSchema>;
+export type SourceReadinessCheck = z.infer<typeof SourceReadinessCheckSchema>;
+export type PreparationName = z.infer<typeof PreparationNameSchema>;
+export type MethodId = z.infer<typeof MethodIdSchema>;
+export type SourcePreparationConfig = z.infer<typeof SourcePreparationConfigSchema>;
 export type InterfConfig = z.infer<typeof InterfConfigSchema>;
 export type SourceFolderConfig = z.infer<typeof SourceFolderConfigSchema>;

package/dist/packages/project-model/lib/schema.js

@@ -1,13 +1,8 @@
 import { z } from "zod";
-import { SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, TestCaseExpectSchema, WorkflowIdPattern, WorkflowIdSchema, } from "../../compiler/lib/schema.js";
-const DatasetNamePattern = /^[a-z0-9][a-z0-9-]*$/;
-const RESERVED_DATASET_NAMES = new Set(["tests", "workflows"]);
-export const DatasetNameSchema = z
-    .string()
-    .regex(DatasetNamePattern, "Dataset names must use lowercase letters, numbers, and dashes only.")
-    .refine((value) => !RESERVED_DATASET_NAMES.has(value), "Dataset name is reserved.");
-export const SourceTruthCheckSchema = z.object({
-    id: z.string().regex(WorkflowIdPattern).optional(),
+import { InterfIdPattern, MethodIdSchema, PreparationNameSchema, SourceCompiledMaxAttemptsSchema, SourceCompiledMaxLoopsSchema, TestCaseExpectSchema, } from "../../contracts/lib/schema.js";
+export { MethodIdSchema, PreparationNameSchema, } from "../../contracts/lib/schema.js";
+export const SourceReadinessCheckSchema = z.object({
+    id: z.string().regex(InterfIdPattern).optional(),
     question: z.string().min(1),
     answer: z.string().min(1).optional(),
     expect: TestCaseExpectSchema.optional(),
@@ -17,46 +12,43 @@ export const SourceTruthCheckSchema = z.object({
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
             path: ["answer"],
-            message: "Truth checks need `answer` or `expect`.",
+            message: "Readiness checks need `answer` or `expect`.",
         });
     }
 });
-export const SourceDatasetConfigSchema = z.object({
-    id: z.string().regex(WorkflowIdPattern).optional(),
-    name: DatasetNameSchema,
+export const SourcePreparationConfigSchema = z.object({
+    id: z.string().regex(InterfIdPattern).optional(),
+    name: PreparationNameSchema,
     path: z.string().min(1),
     about: z.string().min(1).optional(),
-    workflow: WorkflowIdSchema.optional(),
+    method: MethodIdSchema.optional(),
     max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
     max_loops: SourceCompiledMaxLoopsSchema.optional(),
-    checks: z.array(SourceTruthCheckSchema).default([]),
+    checks: z.array(SourceReadinessCheckSchema).default([]),
+}).strict();
+export const SourceFolderBindingSchema = z.object({
+    path: z.string().min(1),
 }).strict();
 export const CompiledInterfConfigSchema = z.object({
     type: z.literal("compiled"),
-    name: DatasetNameSchema,
+    name: PreparationNameSchema,
     about: z.string().optional(),
-    workflow: WorkflowIdSchema,
+    method: MethodIdSchema,
     max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
     max_loops: SourceCompiledMaxLoopsSchema.optional(),
-    checks: z.array(SourceTruthCheckSchema).default([]),
-    workflow_origin: z.object({
-        selected: WorkflowIdSchema,
+    checks: z.array(SourceReadinessCheckSchema).default([]),
+    method_origin: z.object({
+        selected: MethodIdSchema,
         local_draft: z.boolean().optional(),
     }).optional(),
     source: z.object({
         path: z.string(),
         control_path: z.string().optional(),
-        dataset_path: z.string(),
+        preparation_path: z.string().optional(),
     }),
 }).passthrough();
 export const InterfConfigSchema = CompiledInterfConfigSchema;
 export const SourceFolderConfigSchema = z.object({
-    datasets: z.array(SourceDatasetConfigSchema).optional(),
-}).strict().superRefine((value, ctx) => {
-    if ((value.datasets?.length ?? 0) === 0) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "Interf project config needs at least one dataset.",
-        });
-    }
-});
+    source_folder: SourceFolderBindingSchema.optional(),
+    preparations: z.array(SourcePreparationConfigSchema).default([]),
+}).strict();

package/dist/packages/project-model/project-paths.d.ts

@@ -1,13 +1,12 @@
 export declare const PROJECT_INTERF_DIR = "interf";
-export declare const DATASET_INTERF_DIR = ".interf";
+export declare const PORTABLE_CONTEXT_INTERF_DIR = ".interf";
 export declare const PORTABLE_CONTEXT_TESTS_DIR = "tests";
 export declare function projectInterfRoot(projectPath: string): string;
-export declare function compiledCompiledPathForDataset(projectPath: string, datasetName: string): string;
-export declare function portableContextPath(projectPath: string, datasetName: string): string;
-export declare function datasetTestsRoot(projectPath: string, datasetName: string): string;
-export type DatasetTestTargetLabel = "file-as-is" | "compiled";
-export declare function datasetTestRunsRoot(projectPath: string, datasetName: string, target: DatasetTestTargetLabel): string;
-export declare function datasetLatestTestStatePath(projectPath: string, datasetName: string): string;
-export declare function datasetLatestTestSummaryPath(projectPath: string, datasetName: string): string;
-export declare function normalizeDatasetTestRunId(input: string): string;
-export declare function datasetTestRunPath(projectPath: string, datasetName: string, target: DatasetTestTargetLabel, generatedAt: string, runId: string, runSuffix?: string | null): string;
+export declare function portableContextPath(projectPath: string, preparationName: string): string;
+export declare function preparationTestsRoot(projectPath: string, preparationName: string): string;
+export type PreparationTestTargetLabel = "file-as-is" | "compiled";
+export declare function preparationTestRunsRoot(projectPath: string, preparationName: string, target: PreparationTestTargetLabel): string;
+export declare function preparationLatestReadinessRunPath(projectPath: string, preparationName: string): string;
+export declare function preparationLatestReadinessSummaryPath(projectPath: string, preparationName: string): string;
+export declare function normalizePreparationTestRunId(input: string): string;
+export declare function preparationTestRunPath(projectPath: string, preparationName: string, target: PreparationTestTargetLabel, generatedAt: string, runId: string, runSuffix?: string | null): string;

package/dist/packages/project-model/project-paths.js

@@ -1,29 +1,26 @@
 import { join } from "node:path";
 export const PROJECT_INTERF_DIR = "interf";
-export const DATASET_INTERF_DIR = ".interf";
+export const PORTABLE_CONTEXT_INTERF_DIR = ".interf";
 export const PORTABLE_CONTEXT_TESTS_DIR = "tests";
 export function projectInterfRoot(projectPath) {
     return join(projectPath, PROJECT_INTERF_DIR);
 }
-export function compiledCompiledPathForDataset(projectPath, datasetName) {
-    return join(projectInterfRoot(projectPath), datasetName);
+export function portableContextPath(projectPath, preparationName) {
+    return join(projectInterfRoot(projectPath), preparationName);
 }
-export function portableContextPath(projectPath, datasetName) {
-    return compiledCompiledPathForDataset(projectPath, datasetName);
+export function preparationTestsRoot(projectPath, preparationName) {
+    return join(portableContextPath(projectPath, preparationName), PORTABLE_CONTEXT_INTERF_DIR, PORTABLE_CONTEXT_TESTS_DIR);
 }
-export function datasetTestsRoot(projectPath, datasetName) {
-    return join(portableContextPath(projectPath, datasetName), DATASET_INTERF_DIR, PORTABLE_CONTEXT_TESTS_DIR);
+export function preparationTestRunsRoot(projectPath, preparationName, target) {
+    return join(preparationTestsRoot(projectPath, preparationName), target, "runs");
 }
-export function datasetTestRunsRoot(projectPath, datasetName, target) {
-    return join(datasetTestsRoot(projectPath, datasetName), target, "runs");
+export function preparationLatestReadinessRunPath(projectPath, preparationName) {
+    return join(preparationTestsRoot(projectPath, preparationName), "latest.json");
 }
-export function datasetLatestTestStatePath(projectPath, datasetName) {
-    return join(datasetTestsRoot(projectPath, datasetName), "latest.json");
+export function preparationLatestReadinessSummaryPath(projectPath, preparationName) {
+    return join(preparationTestsRoot(projectPath, preparationName), "latest.md");
 }
-export function datasetLatestTestSummaryPath(projectPath, datasetName) {
-    return join(datasetTestsRoot(projectPath, datasetName), "latest.md");
-}
-export function normalizeDatasetTestRunId(input) {
+export function normalizePreparationTestRunId(input) {
     return input
         .toLowerCase()
         .trim()
@@ -31,6 +28,6 @@ export function normalizeDatasetTestRunId(input) {
         .replace(/^-+|-+$/g, "")
         .slice(0, 80);
 }
-export function datasetTestRunPath(projectPath, datasetName, target, generatedAt, runId, runSuffix) {
-    return join(datasetTestRunsRoot(projectPath, datasetName, target), `${generatedAt.replace(/[:.]/g, "-")}-${runId}${runSuffix ? `-${normalizeDatasetTestRunId(runSuffix)}` : ""}.json`);
+export function preparationTestRunPath(projectPath, preparationName, target, generatedAt, runId, runSuffix) {
+    return join(preparationTestRunsRoot(projectPath, preparationName, target), `${generatedAt.replace(/[:.]/g, "-")}-${runId}${runSuffix ? `-${normalizePreparationTestRunId(runSuffix)}` : ""}.json`);
 }

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

@@ -1,4 +1,4 @@
-import { type InterfConfig, type SourceTruthCheck, type SourceDatasetConfig, type SourceFolderConfig } from "./lib/schema.js";
+import { type InterfConfig, type SourceFolderBinding, type SourceReadinessCheck, type SourcePreparationConfig, type SourceFolderConfig } from "./lib/schema.js";
 import type { TestSpec, TestTargetType } from "../testing/lib/schema.js";
 export declare const SOURCE_FOLDER_CONFIG_FILE = "interf.json";
 export declare const SOURCE_FOLDER_CONFIG_PATH = "interf/interf.json";
@@ -7,37 +7,39 @@ export interface LoadedSourceTestSpec extends TestSpec {
     filePath: string;
 }
 export declare function sourceFolderConfigPath(sourcePath: string): string;
-export declare function legacySourceFolderConfigPath(sourcePath: string): string;
 export declare function resolveSourceFolderConfigPath(sourcePath: string): string;
-export declare function migrateLegacySourceFolderConfig(sourcePath: string): boolean;
-export declare function fingerprintTruthChecks(checks: SourceTruthCheck[]): string;
+export declare function fingerprintReadinessChecks(checks: SourceReadinessCheck[]): string;
 export declare function loadSourceFolderConfig(sourcePath: string): SourceFolderConfig | null;
 export interface WritableSourceProjectConfig {
-    datasets?: SourceDatasetConfig[];
+    source_folder?: SourceFolderBinding;
+    preparations?: SourcePreparationConfig[];
 }
-export declare function listSourceDatasetConfigs(config: SourceFolderConfig | null): SourceDatasetConfig[];
-export declare function resolveDatasetCompileMaxAttempts(datasetConfig: Pick<SourceDatasetConfig, "max_attempts">, override?: number | null): number | null;
-export declare function resolveDatasetCompileMaxLoops(datasetConfig: Pick<SourceDatasetConfig, "max_loops">, override?: number | null): number | null;
-export declare function getDefaultSourceDatasetConfig(config: SourceFolderConfig | null): SourceDatasetConfig | null;
-export declare function findSourceDatasetConfig(config: SourceFolderConfig | null, datasetName: string): SourceDatasetConfig | null;
+export { DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig } from "../methods/method-resolution.js";
+export declare function listSourcePreparationConfigs(config: SourceFolderConfig | null): SourcePreparationConfig[];
+export declare function resolvePreparationCompileMaxAttempts(preparationConfig: Pick<SourcePreparationConfig, "max_attempts">, override?: number | null): number | null;
+export declare function resolvePreparationCompileMaxLoops(preparationConfig: Pick<SourcePreparationConfig, "max_loops">, override?: number | null): number | null;
+export declare function getDefaultSourcePreparationConfig(config: SourceFolderConfig | null): SourcePreparationConfig | null;
+export declare function findSourcePreparationConfig(config: SourceFolderConfig | null, preparationName: string): SourcePreparationConfig | null;
+export declare function configuredSourceFolderPath(config: SourceFolderConfig | WritableSourceProjectConfig | null | undefined): string | null;
+export declare function resolveConfiguredSourceFolderPath(sourcePath: string, config?: SourceFolderConfig | WritableSourceProjectConfig | null | undefined): string | null;
 export declare function saveSourceFolderConfig(sourcePath: string, config: WritableSourceProjectConfig): void;
-export declare function appendSourceDatasetChecks(sourcePath: string, datasetName: string, checks: SourceTruthCheck[]): void;
-export declare function upsertSourceDatasetConfig(sourcePath: string, datasetConfig: SourceDatasetConfig, options?: {
+export declare function appendSourcePreparationChecks(sourcePath: string, preparationName: string, checks: SourceReadinessCheck[]): void;
+export declare function upsertSourcePreparationConfig(sourcePath: string, preparationConfig: SourcePreparationConfig, options?: {
     matchName?: string;
 }): void;
 export declare function compiledMaxAttempts(maxAttempts: number | null | undefined): number | undefined;
 export declare function compiledMaxLoops(maxLoops: number | null | undefined): number | undefined;
-export declare function sourceDatasetConfigFromInterfConfig(config: InterfConfig, datasetPath?: string): SourceDatasetConfig;
-export declare function loadCompiledDatasetConfig(compiledPath: string): SourceDatasetConfig | null;
+export declare function sourcePreparationConfigFromInterfConfig(config: InterfConfig, preparationPath?: string): SourcePreparationConfig;
+export declare function loadCompiledPreparationConfig(compiledPath: string): SourcePreparationConfig | null;
 export declare function saveCompiledInterfConfig(compiledPath: string, config: InterfConfig): InterfConfig;
-export declare function syncCompiledInterfConfigFromSourceDatasetConfig(compiledPath: string, datasetConfig: SourceDatasetConfig): InterfConfig;
+export declare function syncCompiledInterfConfigFromSourcePreparationConfig(compiledPath: string, preparationConfig: SourcePreparationConfig): InterfConfig;
 export declare function buildTestSpecFromSourceFolderConfig(options: {
     sourcePath: string;
     targetName?: string | null;
     targetType?: TestTargetType;
 }): LoadedSourceTestSpec | null;
-export declare function buildTestSpecFromCompiledDatasetConfig(options: {
+export declare function buildTestSpecFromCompiledPreparationConfig(options: {
     compiledPath: string;
     targetType?: TestTargetType;
 }): LoadedSourceTestSpec | null;
-export declare function resolveSourceDatasetPath(projectPath: string, datasetConfig: Pick<SourceDatasetConfig, "path">): string;
+export declare function resolveSourcePreparationPath(projectPath: string, preparationConfig: Pick<SourcePreparationConfig, "path">): string;