@interf/compiler 0.7.3 → 0.9.3

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

@@ -1,14 +1,15 @@
 import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { join, relative, resolve, sep } from "node:path";
+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 } from "../shared/path-guards.js";
+import { assertPathWithinRoot, isPathWithinRoot } from "../shared/path-guards.js";
 import { defaultControlPathForCompiled, resolveSourceControlPathForCompiled, compiledInterfConfigPath, compiledInterfRoot, } from "../compiler/compiled-paths.js";
 import { projectInterfRoot, PROJECT_INTERF_DIR } from "./project-paths.js";
 export const SOURCE_FOLDER_CONFIG_FILE = "interf.json";
@@ -16,56 +17,13 @@ export const SOURCE_FOLDER_CONFIG_PATH = `${PROJECT_INTERF_DIR}/${SOURCE_FOLDER_
 export function sourceFolderConfigPath(sourcePath) {
     return join(projectInterfRoot(sourcePath), SOURCE_FOLDER_CONFIG_FILE);
 }
-export function legacySourceFolderConfigPath(sourcePath) {
-    return join(sourcePath, SOURCE_FOLDER_CONFIG_FILE);
-}
 export function resolveSourceFolderConfigPath(sourcePath) {
-    const primaryPath = sourceFolderConfigPath(sourcePath);
-    if (existsSync(primaryPath))
-        return primaryPath;
-    const legacyPath = legacySourceFolderConfigPath(sourcePath);
-    if (existsSync(legacyPath))
-        return legacyPath;
-    return primaryPath;
+    return sourceFolderConfigPath(sourcePath);
 }
 function readSourceFolderConfigFile(filePath) {
     return readJsonFileWithSchema(filePath, "Interf project config", SourceFolderConfigSchema);
 }
-function readJsonFileUncheckedQuiet(filePath) {
-    try {
-        return JSON.parse(readFileSync(filePath, "utf-8"));
-    }
-    catch {
-        return null;
-    }
-}
-function isValidLegacySourceFolderConfig(sourcePath) {
-    const legacyPath = legacySourceFolderConfigPath(sourcePath);
-    if (!existsSync(legacyPath))
-        return false;
-    const raw = readJsonFileUncheckedQuiet(legacyPath);
-    return SourceFolderConfigSchema.safeParse(raw).success;
-}
-export function migrateLegacySourceFolderConfig(sourcePath) {
-    const primaryPath = sourceFolderConfigPath(sourcePath);
-    const legacyPath = legacySourceFolderConfigPath(sourcePath);
-    if (existsSync(primaryPath) || !existsSync(legacyPath))
-        return false;
-    if (!isValidLegacySourceFolderConfig(sourcePath))
-        return false;
-    mkdirSync(projectInterfRoot(sourcePath), { recursive: true });
-    renameSync(legacyPath, primaryPath);
-    return true;
-}
-function removeLegacySourceFolderConfig(sourcePath) {
-    const legacyPath = legacySourceFolderConfigPath(sourcePath);
-    if (!existsSync(legacyPath))
-        return;
-    if (!isValidLegacySourceFolderConfig(sourcePath))
-        return;
-    rmSync(legacyPath, { force: true });
-}
-function normalizeTruthChecks(cases) {
+function normalizeReadinessChecks(cases) {
     const seen = new Set();
     return cases.map((caseSpec, index) => {
         const baseId = slugify(caseSpec.id ?? caseSpec.question) || `check-${index + 1}`;
@@ -85,7 +43,7 @@ function normalizeTruthChecks(cases) {
         };
     });
 }
-export function fingerprintTruthChecks(checks) {
+export function fingerprintReadinessChecks(checks) {
     const normalized = checks.map((check) => ({
         question: check.question.trim(),
         ...(check.answer ? { answer: check.answer.trim() } : {}),
@@ -103,11 +61,19 @@ export function loadSourceFolderConfig(sourcePath) {
         return null;
     return readSourceFolderConfigFile(filePath);
 }
-export function listSourceDatasetConfigs(config) {
-    return config?.datasets ?? [];
+export { DEFAULT_METHOD_ID, methodIdForSourcePreparationConfig } from "../methods/method-resolution.js";
+function normalizeSourcePreparationConfig(preparationConfig) {
+    const method = methodIdForSourcePreparationConfig(preparationConfig);
+    return {
+        ...preparationConfig,
+        ...(method ? { method } : {}),
+    };
+}
+export function listSourcePreparationConfigs(config) {
+    return (config?.preparations ?? []).map((preparation) => normalizeSourcePreparationConfig(preparation));
 }
-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);
@@ -115,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);
@@ -124,89 +90,106 @@ export function resolveDatasetCompileMaxLoops(datasetConfig, override = null) {
         return 1;
     return Math.min(3, normalized);
 }
-export function getDefaultSourceDatasetConfig(config) {
-    const datasets = listSourceDatasetConfigs(config);
-    return datasets[0] ?? null;
+export function getDefaultSourcePreparationConfig(config) {
+    const preparations = listSourcePreparationConfigs(config);
+    return preparations[0] ?? null;
+}
+export function findSourcePreparationConfig(config, preparationName) {
+    return listSourcePreparationConfigs(config).find((preparation) => preparation.name === preparationName) ?? null;
 }
-export function findSourceDatasetConfig(config, datasetName) {
-    return listSourceDatasetConfigs(config).find((dataset) => dataset.name === datasetName) ?? null;
+export function configuredSourceFolderPath(config) {
+    return config?.source_folder?.path ?? null;
+}
+export function resolveConfiguredSourceFolderPath(sourcePath, config = loadSourceFolderConfig(sourcePath)) {
+    const configuredPath = configuredSourceFolderPath(config);
+    return configuredPath ? resolve(sourcePath, configuredPath) : null;
 }
 function toWritableSourceProjectConfig(config) {
-    const datasets = config?.datasets ?? [];
-    if (datasets.length > 0) {
+    const preparations = config?.preparations ?? [];
+    const sourceFolder = config?.source_folder;
+    if (preparations.length > 0) {
         return {
-            datasets: datasets.map((dataset) => toWritableSourceDatasetConfig(dataset)),
+            ...(sourceFolder ? { source_folder: sourceFolder } : {}),
+            preparations: preparations.map((preparation) => toWritableSourcePreparationConfig(preparation)),
         };
     }
-    return {};
+    return {
+        ...(sourceFolder ? { source_folder: sourceFolder } : {}),
+        preparations: [],
+    };
 }
-function toWritableSourceDatasetConfig(dataset) {
+function toWritableSourcePreparationConfig(preparation) {
+    const method = methodIdForSourcePreparationConfig(preparation);
     return {
-        name: dataset.name,
-        path: dataset.path,
-        ...(dataset.about ? { about: dataset.about } : {}),
-        ...(dataset.workflow && dataset.workflow !== "interf" ? { workflow: dataset.workflow } : {}),
-        ...(typeof dataset.max_attempts === "number" ? { max_attempts: dataset.max_attempts } : {}),
-        ...(typeof dataset.max_loops === "number" ? { max_loops: dataset.max_loops } : {}),
-        checks: dataset.checks,
+        name: preparation.name,
+        path: preparation.path,
+        ...(preparation.about ? { about: preparation.about } : {}),
+        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,
     };
 }
 export function saveSourceFolderConfig(sourcePath, config) {
+    const existing = loadSourceFolderConfig(sourcePath);
+    const mergedConfig = {
+        ...(existing?.source_folder && !config.source_folder ? { source_folder: existing.source_folder } : {}),
+        ...config,
+    };
     mkdirSync(projectInterfRoot(sourcePath), { recursive: true });
-    writeFileSync(sourceFolderConfigPath(sourcePath), JSON.stringify(toWritableSourceProjectConfig(config), null, 2) + "\n");
-    removeLegacySourceFolderConfig(sourcePath);
+    writeFileSync(sourceFolderConfigPath(sourcePath), JSON.stringify(toWritableSourceProjectConfig(mergedConfig), null, 2) + "\n");
 }
-export function appendSourceDatasetChecks(sourcePath, datasetName, checks) {
+export function appendSourcePreparationChecks(sourcePath, preparationName, checks) {
     const existing = loadSourceFolderConfig(sourcePath);
-    const currentDataset = findSourceDatasetConfig(existing, datasetName);
-    const otherDatasets = listSourceDatasetConfigs(existing).filter((dataset) => dataset.name !== datasetName);
-    const currentChecks = currentDataset?.checks ?? [];
-    const nextDataset = {
-        ...toWritableSourceDatasetConfig(currentDataset ?? {
-            name: datasetName,
-            path: `./${datasetName}`,
+    const currentPreparation = findSourcePreparationConfig(existing, preparationName);
+    const otherPreparations = listSourcePreparationConfigs(existing).filter((preparation) => preparation.name !== preparationName);
+    const currentChecks = currentPreparation?.checks ?? [];
+    const nextPreparation = {
+        ...toWritableSourcePreparationConfig(currentPreparation ?? {
+            name: preparationName,
+            path: `./${preparationName}`,
             checks: [],
         }),
         checks: [...currentChecks, ...checks],
     };
     saveSourceFolderConfig(sourcePath, {
-        datasets: [
-            nextDataset,
-            ...otherDatasets,
+        preparations: [
+            nextPreparation,
+            ...otherPreparations,
         ],
     });
 }
-export function upsertSourceDatasetConfig(sourcePath, datasetConfig, options = {}) {
+export function upsertSourcePreparationConfig(sourcePath, preparationConfig, options = {}) {
     const existing = loadSourceFolderConfig(sourcePath);
-    const datasets = listSourceDatasetConfigs(existing);
-    const candidateNames = Array.from(new Set([datasetConfig.name, options.matchName].filter((value) => Boolean(value))));
-    const existingIndex = datasets.findIndex((entry) => candidateNames.includes(entry.name));
+    const preparations = listSourcePreparationConfigs(existing);
+    const candidateNames = Array.from(new Set([preparationConfig.name, options.matchName].filter((value) => Boolean(value))));
+    const existingIndex = preparations.findIndex((entry) => candidateNames.includes(entry.name));
     if (existingIndex >= 0) {
-        datasets[existingIndex] = datasetConfig;
+        preparations[existingIndex] = normalizeSourcePreparationConfig(preparationConfig);
     }
     else {
-        datasets.push(datasetConfig);
+        preparations.push(normalizeSourcePreparationConfig(preparationConfig));
     }
     saveSourceFolderConfig(sourcePath, {
-        datasets,
+        preparations,
     });
 }
 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, datasetPath = `./${config.name}`) {
+export function sourcePreparationConfigFromInterfConfig(config, preparationPath = `./${config.name}`) {
     return {
         name: config.name,
-        path: datasetPath,
+        path: preparationPath,
         ...(config.about ? { about: config.about } : {}),
-        ...(config.workflow ? { workflow: config.workflow } : {}),
+        method: config.method,
         ...(typeof config.max_attempts === "number"
             ? { max_attempts: config.max_attempts }
             : {}),
@@ -216,39 +199,50 @@ export function sourceDatasetConfigFromInterfConfig(config, datasetPath = `./${c
         checks: config.checks ?? [],
     };
 }
-export function loadCompiledDatasetConfig(compiledPath) {
+export function loadCompiledPreparationConfig(compiledPath) {
     const config = readInterfConfig(compiledPath);
     if (!config)
         return null;
     const projectPath = resolveSourceControlPathForCompiled(compiledPath);
-    const configuredDatasets = listSourceDatasetConfigs(loadSourceFolderConfig(projectPath));
-    const fallbackDatasetPath = configuredDatasets.length === 1
-        ? configuredDatasets[0].path
+    const configuredPreparations = listSourcePreparationConfigs(loadSourceFolderConfig(projectPath));
+    const defaultPreparationPath = configuredPreparations.length === 1
+        ? configuredPreparations[0].path
         : `./${config.name}`;
-    const datasetPath = typeof config.source?.dataset_path === "string" && config.source.dataset_path.length > 0
-        ? relative(projectPath, assertPathWithinRoot(projectPath, resolve(compiledPath, config.source.dataset_path), "Compiled context source path")).split(sep).join("/") || fallbackDatasetPath
-        : fallbackDatasetPath;
-    return sourceDatasetConfigFromInterfConfig(config, datasetPath);
+    const sourceBinding = typeof config.source?.preparation_path === "string" && config.source.preparation_path.length > 0
+        ? config.source.preparation_path
+        : null;
+    const preparationPath = sourceBinding
+        ? (() => {
+            const sourceAbsolutePath = resolve(compiledPath, sourceBinding);
+            if (!isPathWithinRoot(projectPath, sourceAbsolutePath)) {
+                return sourceAbsolutePath;
+            }
+            return relative(projectPath, sourceAbsolutePath).split(sep).join("/") || defaultPreparationPath;
+        })()
+        : defaultPreparationPath;
+    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 = resolve(projectPath, datasetConfig.path);
-    const datasetRelativePath = relative(compiledPath, datasetAbsolutePath).split(sep).join("/") || ".";
-    const workflowId = datasetConfig.workflow ?? current?.workflow ?? "interf";
-    const workflowChanged = current?.workflow !== undefined && current.workflow !== workflowId;
-    const workflowOrigin = workflowChanged || !current?.workflow_origin
+    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
         ? {
-            selected: workflowId,
+            selected: methodId,
             local_draft: false,
         }
-        : current.workflow_origin;
-    const { type: _ignoredType, name: _ignoredName, about: _ignoredAbout, workflow: _ignoredWorkflow, max_attempts: _ignoredMaxAttempts, max_loops: _ignoredMaxLoops, checks: _ignoredChecks, workflow_origin: _ignoredWorkflowOrigin, source: _ignoredSource, ...passthrough } = current ?? {};
+        : current.method_origin;
+    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 ? {
@@ -258,31 +252,31 @@ export function syncCompiledInterfConfigFromSourceDatasetConfig(compiledPath, da
             },
         } : {}),
         type: "compiled",
-        name: datasetConfig.name,
-        ...(datasetConfig.about ? { about: datasetConfig.about } : {}),
-        workflow: workflowId,
-        ...(typeof datasetConfig.max_attempts === "number"
-            ? { max_attempts: datasetConfig.max_attempts }
+        name: preparationConfig.name,
+        ...(preparationConfig.about ? { about: preparationConfig.about } : {}),
+        method: methodId,
+        ...(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,
-        workflow_origin: workflowOrigin,
+        checks: preparationConfig.checks,
+        method_origin: methodOrigin,
         source: {
             path: current?.source?.path ?? "./raw",
             control_path: defaultControlPathForCompiled(compiledPath),
-            dataset_path: datasetRelativePath,
+            preparation_path: preparationRelativePath,
         },
     };
     const saved = saveCompiledInterfConfig(compiledPath, nextConfig);
-    if (workflowChanged) {
+    if (methodChanged) {
         const sourcePath = projectPath;
-        const selectedWorkflow = getCompiledWorkflow(workflowId, { sourcePath });
-        seedCompiledWorkflowPackage({
+        const selectedMethod = getCompiledMethod(methodId, { sourcePath });
+        seedCompiledMethodPackage({
             compiledPath,
             sourcePath,
-            workflowId: selectedWorkflow.id,
+            methodId: selectedMethod.id,
         });
     }
     refreshCompiledBootstrapGuidance(compiledPath);
@@ -297,8 +291,8 @@ function buildLoadedTestSpec(options) {
         filePath: options.filePath,
         type: options.targetType,
         name: options.name,
-        description: options.about ?? options.fallbackDescription,
-        cases: normalizeTruthChecks(options.checks),
+        description: options.about ?? options.defaultDescription,
+        cases: normalizeReadinessChecks(options.checks),
     };
 }
 export function buildTestSpecFromSourceFolderConfig(options) {
@@ -306,14 +300,14 @@ export function buildTestSpecFromSourceFolderConfig(options) {
     const config = loadSourceFolderConfig(sourcePath);
     if (!config)
         return null;
-    const datasets = listSourceDatasetConfigs(config);
-    if (datasets.length === 0)
+    const preparations = listSourcePreparationConfigs(config);
+    if (preparations.length === 0)
         return null;
     const match = targetName
-        ? datasets.find((entry) => entry.name === targetName)
-        : datasets.length === 1
-            ? datasets[0]
-            : getDefaultSourceDatasetConfig(config);
+        ? preparations.find((entry) => entry.name === targetName)
+        : preparations.length === 1
+            ? preparations[0]
+            : getDefaultSourcePreparationConfig(config);
     if (!match)
         return null;
     const configPath = resolveSourceFolderConfigPath(sourcePath);
@@ -324,12 +318,12 @@ export function buildTestSpecFromSourceFolderConfig(options) {
         checks: match.checks,
         targetType,
         filePath: targetType === "raw"
-            ? `${configPath}#datasets/${match.name}:file-as-is`
-            : `${configPath}#datasets/${match.name}:compiled`,
-        fallbackDescription: `Derived from saved dataset checks in ${SOURCE_FOLDER_CONFIG_PATH}`,
+            ? `${configPath}#preparations/${match.name}:source-files`
+            : `${configPath}#preparations/${match.name}:portable-context`,
+        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);
@@ -343,9 +337,14 @@ export function buildTestSpecFromCompiledDatasetConfig(options) {
         filePath: targetType === "raw"
             ? `${configPath}#checks:file-as-is`
             : `${configPath}#checks:compiled`,
-        fallbackDescription: "Derived from checks in the compiled context config.",
+        defaultDescription: "Derived from checks in the portable context config.",
     });
 }
-export function resolveSourceDatasetPath(projectPath, datasetConfig) {
-    return assertPathWithinRoot(projectPath, resolve(projectPath, datasetConfig.path), "Dataset path");
+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");
 }

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

@@ -0,0 +1,11 @@
+export declare function listVisibleSourceFolders(projectPath: 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 defaultSourcePreparationPathForPrompt(name: string, introStyle: "first" | "additional" | "edit", projectPath?: string): string;

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

@@ -0,0 +1,110 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { isAbsolute, join, relative, sep } from "node:path";
+import { slugify } from "../shared/naming.js";
+import { resolveSourcePreparationPath } from "./source-config.js";
+import { isPathWithinRoot } from "../shared/path-guards.js";
+const DEFAULT_PREPARATION_NAME = "default";
+const IGNORED_SOURCE_FOLDER_ENTRIES = new Set([
+    ".DS_Store",
+    ".git",
+    ".interf",
+    "interf",
+    "interf.json",
+    "node_modules",
+]);
+export function listVisibleSourceFolders(projectPath) {
+    let rootEntries = [];
+    try {
+        rootEntries = readdirSync(projectPath);
+    }
+    catch {
+        return [];
+    }
+    const visibleEntries = rootEntries.filter((entry) => (!IGNORED_SOURCE_FOLDER_ENTRIES.has(entry) && !entry.startsWith(".")));
+    const visibleDirectories = [];
+    for (const entry of visibleEntries) {
+        try {
+            const entryPath = join(projectPath, entry);
+            if (statSync(entryPath).isDirectory()) {
+                visibleDirectories.push(entry);
+            }
+        }
+        catch {
+            // Ignore unreadable entries.
+        }
+    }
+    return visibleDirectories.sort((left, right) => left.localeCompare(right));
+}
+export function isReservedSourcePreparationPath(relativePath) {
+    const normalized = relativePath.replace(/\\/g, "/").replace(/^\.\/+/, "");
+    return normalized === "interf" ||
+        normalized.startsWith("interf/") ||
+        normalized === ".interf" ||
+        normalized.startsWith(".interf/");
+}
+export function normalizeSourcePreparationPathForConfig(projectPath, value) {
+    const trimmedValue = value.trim();
+    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.");
+    }
+    if (isAbsolute(trimmedValue) && !isPathWithinRoot(projectPath, resolvedPath)) {
+        if (!existsSync(resolvedPath)) {
+            throw new Error("Pick an existing source folder.");
+        }
+        if (!statSync(resolvedPath).isDirectory()) {
+            throw new Error("Source folder must be a directory.");
+        }
+        return resolvedPath;
+    }
+    if (isReservedSourcePreparationPath(relativePath)) {
+        throw new Error("Pick an existing source folder, not `interf/` or `.interf/`.");
+    }
+    if (!existsSync(resolvedPath)) {
+        throw new Error("Pick an existing source folder.");
+    }
+    if (!statSync(resolvedPath).isDirectory()) {
+        throw new Error("Source folder must be a directory.");
+    }
+    return relativePath.startsWith("./") ? relativePath : `./${relativePath}`;
+}
+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_PREPARATION_NAME;
+}
+export function findSingleSourceFolderCandidate(projectPath) {
+    const visibleDirectories = listVisibleSourceFolders(projectPath);
+    if (visibleDirectories.length !== 1) {
+        return null;
+    }
+    return `./${visibleDirectories[0]}`;
+}
+export function listSourceFolderChoices(projectPath = process.cwd()) {
+    return listVisibleSourceFolders(projectPath).map((entry) => ({
+        value: `./${entry}`,
+        label: entry,
+        hint: `Use ./${entry} as the source folder`,
+    }));
+}
+export function defaultSourcePreparationPathForPrompt(name, introStyle, projectPath = process.cwd()) {
+    const namedFolderPath = join(projectPath, name);
+    if (existsSync(namedFolderPath)) {
+        try {
+            if (statSync(namedFolderPath).isDirectory()) {
+                return `./${name}`;
+            }
+        }
+        catch {
+            // Fall through to the normal default.
+        }
+    }
+    if (introStyle === "first") {
+        return findSingleSourceFolderCandidate(projectPath) ?? `./${name}`;
+    }
+    return `./${name}`;
+}

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";