@interf/compiler 0.9.1 → 0.9.4

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, methodIdForSourcePreparationConfig, 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,25 +89,23 @@ 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 effectiveWorkflowId = workflowId === "interf"
-        ? methodIdForSourcePreparationConfig(savedCompiled) ?? workflowId
-        : workflowId;
-    const selectedWorkflow = getCompiledWorkflow(effectiveWorkflowId, { 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 source folder path.");
     })();
@@ -114,7 +113,7 @@ export function createCompiled(name, sourcePath, workflowId = "interf", about, d
         type: "compiled",
         name,
         ...(resolvedAbout ? { about: resolvedAbout } : {}),
-        method: selectedWorkflow.id,
+        method: selectedMethod.id,
         ...(typeof savedCompiled?.max_attempts === "number"
             ? { max_attempts: savedCompiled.max_attempts }
             : {}),
@@ -123,17 +122,17 @@ export function createCompiled(name, sourcePath, workflowId = "interf", about, d
             : {}),
         checks: savedCompiled?.checks ?? [],
         method_origin: {
-            selected: selectedWorkflow.id,
+            selected: selectedMethod.id,
             local_draft: false,
         },
         source: {
             path: "./raw",
             control_path: defaultControlPathForCompiled(compiledPath),
-            preparation_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, METHOD_CONTAINER_NAME, WORKFLOW_CONTAINER_NAME, LEGACY_WORKFLOW_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, METHOD_PACKAGE_DIR, WORKFLOW_PACKAGE_DIR, LEGACY_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, METHOD_CONTAINER_NAME, WORKFLOW_CONTAINER_NAME, LEGACY_WORKFLOW_CONTAINER_NAME, TEST_CONTAINER_NAME, INTERF_CONFIG_FILE, METHOD_PACKAGE_DIR, WORKFLOW_PACKAGE_DIR, LEGACY_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,7 +1,6 @@
 import { z } from "zod";
-export declare const DatasetNameSchema: z.ZodString;
-export declare const PreparationNameSchema: z.ZodString;
-export declare const MethodIdSchema: z.ZodString;
+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;
@@ -21,30 +20,6 @@ export declare const SourcePreparationConfigSchema: z.ZodObject<{
     path: z.ZodString;
     about: z.ZodOptional<z.ZodString>;
     method: z.ZodOptional<z.ZodString>;
-    workflow: z.ZodOptional<z.ZodString>;
-    max_attempts: z.ZodOptional<z.ZodNumber>;
-    max_loops: z.ZodOptional<z.ZodNumber>;
-    checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        question: z.ZodString;
-        answer: z.ZodOptional<z.ZodString>;
-        expect: z.ZodOptional<z.ZodObject<{
-            must_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            must_include_one_of: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
-            must_not_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            min_words: z.ZodOptional<z.ZodNumber>;
-            max_words: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-        strictness: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>>;
-}, z.core.$strict>;
-export declare const SourceDatasetConfigSchema: z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-    name: z.ZodString;
-    path: z.ZodString;
-    about: z.ZodOptional<z.ZodString>;
-    method: z.ZodOptional<z.ZodString>;
-    workflow: z.ZodOptional<z.ZodString>;
     max_attempts: z.ZodOptional<z.ZodNumber>;
     max_loops: z.ZodOptional<z.ZodNumber>;
     checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -69,7 +44,6 @@ export declare const CompiledInterfConfigSchema: z.ZodObject<{
     name: z.ZodString;
     about: z.ZodOptional<z.ZodString>;
     method: z.ZodString;
-    workflow: z.ZodOptional<z.ZodString>;
     max_attempts: z.ZodOptional<z.ZodNumber>;
     max_loops: z.ZodOptional<z.ZodNumber>;
     checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -89,16 +63,10 @@ export declare const CompiledInterfConfigSchema: z.ZodObject<{
         selected: z.ZodString;
         local_draft: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
-    workflow_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>;
         preparation_path: z.ZodOptional<z.ZodString>;
-        source_folder_path: z.ZodOptional<z.ZodString>;
-        dataset_path: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$loose>;
 export declare const InterfConfigSchema: z.ZodObject<{
@@ -106,7 +74,6 @@ export declare const InterfConfigSchema: z.ZodObject<{
     name: z.ZodString;
     about: z.ZodOptional<z.ZodString>;
     method: z.ZodString;
-    workflow: z.ZodOptional<z.ZodString>;
     max_attempts: z.ZodOptional<z.ZodNumber>;
     max_loops: z.ZodOptional<z.ZodNumber>;
     checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -126,16 +93,10 @@ export declare const InterfConfigSchema: z.ZodObject<{
         selected: z.ZodString;
         local_draft: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
-    workflow_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>;
         preparation_path: z.ZodOptional<z.ZodString>;
-        source_folder_path: z.ZodOptional<z.ZodString>;
-        dataset_path: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$loose>;
 export declare const SourceFolderConfigSchema: z.ZodObject<{
@@ -148,30 +109,6 @@ export declare const SourceFolderConfigSchema: z.ZodObject<{
         path: z.ZodString;
         about: z.ZodOptional<z.ZodString>;
         method: z.ZodOptional<z.ZodString>;
-        workflow: z.ZodOptional<z.ZodString>;
-        max_attempts: z.ZodOptional<z.ZodNumber>;
-        max_loops: z.ZodOptional<z.ZodNumber>;
-        checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
-            id: z.ZodOptional<z.ZodString>;
-            question: z.ZodString;
-            answer: z.ZodOptional<z.ZodString>;
-            expect: z.ZodOptional<z.ZodObject<{
-                must_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                must_include_one_of: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
-                must_not_include: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                min_words: z.ZodOptional<z.ZodNumber>;
-                max_words: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>;
-            strictness: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>>;
-    }, z.core.$strict>>>;
-    datasets: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        name: z.ZodString;
-        path: z.ZodString;
-        about: z.ZodOptional<z.ZodString>;
-        method: z.ZodOptional<z.ZodString>;
-        workflow: z.ZodOptional<z.ZodString>;
         max_attempts: z.ZodOptional<z.ZodNumber>;
         max_loops: z.ZodOptional<z.ZodNumber>;
         checks: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -191,7 +128,6 @@ export declare const SourceFolderConfigSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type SourceFolderBinding = z.infer<typeof SourceFolderBindingSchema>;
 export type SourceReadinessCheck = z.infer<typeof SourceReadinessCheckSchema>;
-export type SourceDatasetConfig = z.infer<typeof SourceDatasetConfigSchema>;
 export type PreparationName = z.infer<typeof PreparationNameSchema>;
 export type MethodId = z.infer<typeof MethodIdSchema>;
 export type SourcePreparationConfig = z.infer<typeof SourcePreparationConfigSchema>;

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

@@ -1,15 +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", "methods", "workflows"]);
-export const DatasetNameSchema = z
-    .string()
-    .regex(DatasetNamePattern, "Preparation names must use lowercase letters, numbers, and dashes only.")
-    .refine((value) => !RESERVED_DATASET_NAMES.has(value), "Preparation name is reserved.");
-export const PreparationNameSchema = DatasetNameSchema;
-export const MethodIdSchema = WorkflowIdSchema;
+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(WorkflowIdPattern).optional(),
+    id: z.string().regex(InterfIdPattern).optional(),
     question: z.string().min(1),
     answer: z.string().min(1).optional(),
     expect: TestCaseExpectSchema.optional(),
@@ -24,26 +17,23 @@ export const SourceReadinessCheckSchema = z.object({
     }
 });
 export const SourcePreparationConfigSchema = z.object({
-    id: z.string().regex(WorkflowIdPattern).optional(),
+    id: z.string().regex(InterfIdPattern).optional(),
     name: PreparationNameSchema,
     path: z.string().min(1),
     about: z.string().min(1).optional(),
     method: MethodIdSchema.optional(),
-    workflow: WorkflowIdSchema.optional(),
     max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
     max_loops: SourceCompiledMaxLoopsSchema.optional(),
     checks: z.array(SourceReadinessCheckSchema).default([]),
 }).strict();
-export const SourceDatasetConfigSchema = SourcePreparationConfigSchema;
 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(),
     method: MethodIdSchema,
-    workflow: WorkflowIdSchema.optional(),
     max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
     max_loops: SourceCompiledMaxLoopsSchema.optional(),
     checks: z.array(SourceReadinessCheckSchema).default([]),
@@ -51,22 +41,14 @@ export const CompiledInterfConfigSchema = z.object({
         selected: MethodIdSchema,
         local_draft: z.boolean().optional(),
     }).optional(),
-    workflow_origin: z.object({
-        selected: WorkflowIdSchema,
-        local_draft: z.boolean().optional(),
-    }).optional(),
     source: z.object({
         path: z.string(),
         control_path: z.string().optional(),
         preparation_path: z.string().optional(),
-        source_folder_path: z.string().optional(),
-        dataset_path: z.string().optional(),
     }),
 }).passthrough();
 export const InterfConfigSchema = CompiledInterfConfigSchema;
 export const SourceFolderConfigSchema = z.object({
     source_folder: SourceFolderBindingSchema.optional(),
     preparations: z.array(SourcePreparationConfigSchema).default([]),
-    // Legacy config array. Read for compatibility; new writes use `preparations`.
-    datasets: z.array(SourceDatasetConfigSchema).optional(),
 }).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 SourceFolderBinding, type SourceReadinessCheck, type SourceDatasetConfig, type SourcePreparationConfig, 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";
@@ -13,40 +13,33 @@ export declare function loadSourceFolderConfig(sourcePath: string): SourceFolder
 export interface WritableSourceProjectConfig {
     source_folder?: SourceFolderBinding;
     preparations?: SourcePreparationConfig[];
-    datasets?: SourceDatasetConfig[];
 }
-export declare function methodIdForSourcePreparationConfig(preparationConfig: Pick<SourcePreparationConfig, "method" | "workflow"> | null | undefined): string | null;
+export { DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig } from "../methods/method-resolution.js";
 export declare function listSourcePreparationConfigs(config: SourceFolderConfig | null): SourcePreparationConfig[];
-export declare const listSourceDatasetConfigs: typeof listSourcePreparationConfigs;
-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 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 const getDefaultSourceDatasetConfig: typeof getDefaultSourcePreparationConfig;
 export declare function findSourcePreparationConfig(config: SourceFolderConfig | null, preparationName: string): SourcePreparationConfig | null;
-export declare const findSourceDatasetConfig: typeof findSourcePreparationConfig;
 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, preparationName: string, checks: SourceReadinessCheck[]): void;
-export declare const appendSourcePreparationChecks: typeof appendSourceDatasetChecks;
-export declare function upsertSourceDatasetConfig(sourcePath: string, preparationConfig: SourcePreparationConfig, 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 const upsertSourcePreparationConfig: typeof upsertSourceDatasetConfig;
 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, preparationPath?: string): SourcePreparationConfig;
-export declare function loadCompiledDatasetConfig(compiledPath: string): SourcePreparationConfig | 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: SourcePreparationConfig): 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<SourcePreparationConfig, "path">): string;
-export declare const resolveSourcePreparationPath: typeof resolveSourceDatasetPath;
+export declare function resolveSourcePreparationPath(projectPath: string, preparationConfig: Pick<SourcePreparationConfig, "path">): string;