@interf/compiler 0.4.0 → 0.5.0

package/dist/lib/schema.js

@@ -1,36 +1,49 @@
 import { z } from "zod";
-import { WORKSPACE_CONTRACT_TYPES, WORKSPACE_ZONE_KINDS, } from "./workflow-abi.js";
+import { COMPILED_ZONE_KINDS, } from "./workflow-abi.js";
 const JsonRecordSchema = z.record(z.string(), z.unknown());
-const WORKSPACE_RELATIVE_PATH_SEGMENT = /^(?!\.{1,2}$)[^/\\]+$/;
-function isWorkspaceRelativePath(value) {
+const COMPILED_RELATIVE_PATH_SEGMENT = /^(?!\.{1,2}$)[^/\\]+$/;
+function isCompiledRelativePath(value) {
     if (value.length === 0)
         return false;
     if (value.startsWith("/") || value.startsWith("\\"))
         return false;
     return value
         .split(/[\\/]+/)
-        .every((segment) => WORKSPACE_RELATIVE_PATH_SEGMENT.test(segment));
+        .every((segment) => COMPILED_RELATIVE_PATH_SEGMENT.test(segment));
 }
-export const RuntimeTargetTypeSchema = z.enum(["workspace"]);
-export const TestTargetTypeSchema = z.enum(["workspace", "raw"]);
+export const RuntimeTargetTypeSchema = z.enum(["compiled"]);
+export const TestTargetTypeSchema = z.enum(["compiled", "raw"]);
 export const WorkflowIdPattern = /^[a-z0-9][a-z0-9-]{0,79}$/;
 export const RuntimeStageSchema = z.string().regex(WorkflowIdPattern);
-export const RuntimeContractTypeSchema = z.enum(WORKSPACE_CONTRACT_TYPES);
+export const RuntimeContractTypeSchema = z.string().regex(WorkflowIdPattern);
 export const WorkflowIdSchema = z.string().regex(WorkflowIdPattern);
 export const WorkflowZoneIdSchema = z.string().regex(WorkflowIdPattern);
-export const WorkflowWorkspaceZoneKindSchema = z.enum(WORKSPACE_ZONE_KINDS);
-export const WorkspaceStateSchema = z.object({
-    version: z.literal(1),
+export const WorkflowCompiledZoneKindSchema = z.enum(COMPILED_ZONE_KINDS);
+export const CompiledStageStatusSchema = z.enum(["idle", "running", "succeeded", "failed"]);
+export const CompiledStageStateSchema = z.object({
+    contract_type: RuntimeContractTypeSchema.optional(),
+    status: CompiledStageStatusSchema.optional(),
+    started_at: z.string().nullable().optional(),
+    finished_at: z.string().nullable().optional(),
+    counts: z.record(z.string(), z.number()).optional(),
+    zone_counts: z.record(z.string(), z.number()).optional(),
+    artifacts: z.array(z.string()).optional(),
+    summary: z.string().nullable().optional(),
+    run_id: z.string().nullable().optional(),
+});
+export const CompiledStateSchema = z.object({
+    version: z.number().int().min(1),
     pending: z.array(z.string()),
-    summarized: z.number(),
+    stages: z.record(z.string().regex(WorkflowIdPattern), CompiledStageStateSchema).optional(),
+    last_add: z.string().nullable().optional(),
+    last_compile: z.string().nullable().optional(),
+    summarized: z.number().optional(),
     structured: z.number().optional(),
     shaped: z.number().optional(),
-    compiled: z.number(),
-    last_add: z.string().nullable().optional(),
+    compiled: z.number().optional(),
     last_summarize: z.string().nullable().optional(),
     last_structure: z.string().nullable().optional(),
     last_shape: z.string().nullable().optional(),
-    last_compile: z.string().nullable().optional(),
     inventory_complete: z.boolean().optional(),
     abstracts_read: z.number().optional(),
     full_reads: z.number().optional(),
@@ -53,57 +66,34 @@ export const ViewCardSchema = z.object({
     denominator_metric: z.string().optional(),
     format: z.enum(["number", "fraction", "timestamp"]),
 });
-export const WorkspaceHealthSchema = z.object({
-    kind: z.literal("workspace-health"),
-    version: z.literal(1),
+export const CompiledHealthSchema = z.object({
+    kind: z.literal("compiled-health"),
+    version: z.number().int().min(1),
     generated_at: z.string(),
     target_name: z.string(),
     status: z.enum(["idle", "running", "compiled", "stale", "failed"]),
-    stage: z.enum(["idle", "summarize", "structure", "shape", "compiled", "failed"]),
+    stage: z.union([
+        z.enum(["idle", "compiled", "failed"]),
+        RuntimeStageSchema,
+    ]),
     summary: z.string(),
-    metrics: z.object({
-        source_total: z.number(),
-        source_covered: z.number(),
-        summarized: z.number(),
-        to_summarize: z.number(),
-        compiled: z.number(),
-        to_compile: z.number(),
-        entities: z.number(),
-        claims: z.number(),
-        outputs: z.number(),
-        invalid_frontmatter: z.number(),
-        short_abstracts: z.number(),
-        broken_links: z.number(),
-        warnings: z.number(),
-        errors: z.number(),
-    }),
-    checks: z.object({
-        config_present: z.boolean(),
-        config_valid: z.boolean(),
-        config_type_match: z.boolean(),
-        summaries_present: z.boolean(),
-        inventory_present: z.boolean(),
-        outputs_present: z.boolean(),
-        home_present: z.boolean(),
-        summary_frontmatter_valid: z.boolean(),
-        abstracts_valid: z.boolean(),
-        links_valid: z.boolean(),
-    }),
+    metrics: z.record(z.string(), z.number()),
+    checks: z.record(z.string(), z.boolean()),
 });
-export const WorkspaceViewSpecSchema = z.object({
-    kind: z.literal("workspace-view-spec"),
-    version: z.literal(1),
+export const CompiledViewSpecSchema = z.object({
+    kind: z.literal("compiled-view-spec"),
+    version: z.number().int().min(1),
     generated_at: z.string(),
     target_name: z.string(),
     health_source: z.string(),
     state_source: z.string(),
-    default_note: z.string(),
+    default_note: z.string().nullable(),
     graph_scope: z.array(z.string()),
     cards: z.array(ViewCardSchema),
     sections: z.array(ViewSectionSchema),
 });
-export const WorkspaceRawSnapshotSchema = z.object({
-    kind: z.literal("workspace-raw-snapshot"),
+export const CompiledRawSnapshotSchema = z.object({
+    kind: z.literal("compiled-raw-snapshot"),
     version: z.literal(1),
     generated_at: z.string(),
     target_name: z.string(),
@@ -112,31 +102,31 @@ export const WorkspaceRawSnapshotSchema = z.object({
     source_total: z.number(),
     sample_files: z.array(z.string()),
 });
-export const WorkflowWorkspaceZoneSchema = z.object({
+export const WorkflowCompiledZoneSchema = z.object({
     id: WorkflowZoneIdSchema,
-    path: z.string().min(1).refine(isWorkspaceRelativePath, {
-        message: "Zone paths must stay inside the workspace root",
+    path: z.string().min(1).refine(isCompiledRelativePath, {
+        message: "Zone paths must stay inside the compiled root",
     }),
-    kind: WorkflowWorkspaceZoneKindSchema,
+    kind: WorkflowCompiledZoneKindSchema,
     required: z.boolean(),
     owned_by: z.array(z.string().regex(WorkflowIdPattern)),
     description: z.string().min(1),
 });
-export const WorkflowWorkspaceSchemaSchema = z.object({
-    kind: z.literal("workspace-schema"),
+export const WorkflowCompiledSchemaSchema = z.object({
+    kind: z.literal("compiled-schema"),
     version: z.literal(1),
-    target_type: z.literal("workspace"),
+    target_type: z.literal("compiled"),
     label: z.string().min(1),
-    zones: z.array(WorkflowWorkspaceZoneSchema).min(1),
+    zones: z.array(WorkflowCompiledZoneSchema).min(1),
 });
 export const WorkflowCompilerApiSchema = z.object({
-    kind: z.literal("workspace"),
+    kind: z.literal("compiled"),
     version: z.literal(1),
 });
 export const WorkflowStageZoneAccessSchema = z.array(WorkflowZoneIdSchema).min(1);
 export const ExecutionShellZoneMountSchema = z.object({
     zone_id: WorkflowZoneIdSchema,
-    workspace_path: z.string(),
+    compiled_path: z.string(),
     shell_root_path: z.string(),
     input_mount_path: z.string().nullable(),
     output_mount_path: z.string().nullable(),
@@ -159,20 +149,48 @@ export const RuntimeExecutorInfoSchema = z.object({
     profile: z.string().nullable().optional(),
     timeout_ms: z.number().nullable().optional(),
 });
-export const RuntimeStageInstructionsSchema = z.object({
-    bundled_skill: z.string(),
+export const RuntimeStageInstructionsSchema = z.preprocess((value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const raw = value;
+    const legacyBundledSkill = typeof raw.bundled_skill === "string" && raw.bundled_skill.length > 0
+        ? raw.bundled_skill.split(/[\\/]/).filter(Boolean).pop()
+        : undefined;
+    return {
+        ...raw,
+        stage_skill_dir: raw.stage_skill_dir ?? legacyBundledSkill,
+    };
+}, z.object({
+    stage_skill_dir: z.string().regex(WorkflowIdPattern),
     effective_mode: z.enum(["builtin", "extend", "override"]),
     local_mode: z.enum(["extend", "override"]).nullable(),
     local_docs: z.array(z.string()),
     mode_sources: z.array(z.string()),
-});
-export const RuntimeStageAcceptanceSchema = z.object({
+}));
+export const RuntimeStageAcceptanceSchema = z.preprocess((value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const raw = value;
+    return {
+        ...raw,
+        stage_truthy: raw.stage_truthy ?? raw.state_truthy,
+        stage_equals_counts: raw.stage_equals_counts ?? raw.state_equals_counts,
+        stage_at_least: raw.stage_at_least ?? raw.state_at_least,
+        stage_at_least_counts: raw.stage_at_least_counts ?? raw.state_at_least_counts,
+    };
+}, z.object({
     artifacts_exist: z.array(z.string()).optional(),
-    state_truthy: z.array(z.string()).optional(),
-    state_equals_counts: z.record(z.string(), z.string()).optional(),
-    state_at_least: z.record(z.string(), z.number()).optional(),
-    state_at_least_counts: z.record(z.string(), z.string()).optional(),
-});
+    stage_truthy: z.array(z.string()).optional(),
+    stage_equals_counts: z.record(z.string(), z.string()).optional(),
+    stage_at_least: z.record(z.string(), z.number()).optional(),
+    stage_at_least_counts: z.record(z.string(), z.string()).optional(),
+    zone_counts_at_least: z.record(z.string().regex(WorkflowIdPattern), z.number()).optional(),
+    zone_counts_at_least_counts: z.record(z.string().regex(WorkflowIdPattern), z.string()).optional(),
+    markdown_frontmatter_valid_zones: z.array(WorkflowZoneIdSchema).optional(),
+    markdown_abstract_valid_zones: z.array(WorkflowZoneIdSchema).optional(),
+    wikilinks_valid_in_zones: z.array(WorkflowZoneIdSchema).optional(),
+    artifacts_must_not_contain: z.record(z.string(), z.array(z.string().min(1))).optional(),
+}));
 export const RuntimeStageContractSchema = z.object({
     kind: z.literal("interf-stage-contract"),
     version: z.literal(1),
@@ -240,27 +258,43 @@ export const RuntimeRunSchema = z.object({
     exit_code: z.number().nullable(),
     error: z.string().nullable(),
 });
-const InventoryRecordSchema = JsonRecordSchema;
-export const WorkspaceInventorySchema = z.union([
-    z.object({
-        total: z.number(),
-        files: z.array(InventoryRecordSchema),
-    }),
-    z.object({
-        summary_total: z.number(),
-        summaries: z.array(InventoryRecordSchema),
-    }),
-    z.object({
-        entries: z.array(InventoryRecordSchema),
-        total: z.number().optional(),
-        summary_total: z.number().optional(),
-    }),
-    z.object({
-        items: z.array(InventoryRecordSchema),
-        total: z.number().optional(),
-        summary_total: z.number().optional(),
-    }),
-]);
+export const CompiledInventoryEntrySchema = z.preprocess((value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return value;
+    const raw = value;
+    if (typeof raw.source !== "string" && typeof raw.summary !== "string")
+        return raw;
+    return {
+        input_zone: raw.input_zone ?? "raw",
+        input_path: raw.input_path ?? raw.source,
+        output_zone: raw.output_zone ?? "summaries",
+        output_path: raw.output_path ?? raw.summary,
+        state: raw.state,
+        metadata: {
+            source_kind: raw.source_kind,
+            evidence_tier: raw.evidence_tier,
+            truth_mode: raw.truth_mode,
+            status: raw.status,
+            abstract: raw.abstract,
+            frontmatter_scanned: raw.frontmatter_scanned,
+            abstract_read: raw.abstract_read,
+        },
+    };
+}, z.object({
+    input_zone: WorkflowZoneIdSchema,
+    input_path: z.string().min(1),
+    output_zone: WorkflowZoneIdSchema,
+    output_path: z.string().min(1),
+    state: z.string().min(1).optional(),
+    metadata: JsonRecordSchema.optional(),
+}));
+export const CompiledInventorySchema = z.object({
+    kind: z.literal("compiled-runtime-ledger").optional(),
+    version: z.number().int().min(1).optional(),
+    stage: RuntimeStageSchema.optional(),
+    entries: z.array(CompiledInventoryEntrySchema),
+    total: z.number().int().nonnegative(),
+});
 export const TestCaseExpectSchema = z.object({
     must_include: z.array(z.string().min(1)).optional(),
     must_include_one_of: z.array(z.array(z.string().min(1)).min(1)).optional(),
@@ -315,7 +349,7 @@ export const TestSpecSchema = z.preprocess((value) => {
     const raw = value;
     return {
         ...raw,
-        type: raw.type ?? "workspace",
+        type: raw.type ?? "compiled",
         cases: raw.cases ?? raw.checks,
     };
 }, TestSpecCoreSchema);
@@ -334,46 +368,49 @@ export const SourceTruthCheckSchema = z.object({
         });
     }
 });
-export const SourceWorkspaceMaxAttemptsSchema = z.number().int().min(1).max(5);
-export const SourceWorkspaceMaxLoopsSchema = z.number().int().min(1).max(3);
-export const SourceWorkspaceConfigSchema = z.preprocess((value) => {
+export const SourceCompiledMaxAttemptsSchema = z.number().int().min(1).max(5);
+export const SourceCompiledMaxLoopsSchema = z.number().int().min(1).max(3);
+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 SourceDatasetConfigSchema = z.preprocess((value) => {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return value;
     const raw = value;
-    const legacyRetryPolicy = raw.retry_policy && typeof raw.retry_policy === "object" && !Array.isArray(raw.retry_policy)
-        ? raw.retry_policy
-        : null;
     return {
         ...raw,
-        max_attempts: raw.max_attempts ?? legacyRetryPolicy?.max_attempts,
-        max_loops: raw.max_loops,
+        path: raw.path ?? ".",
     };
 }, z.object({
     id: z.string().regex(WorkflowIdPattern).optional(),
-    name: z.string().min(1),
+    name: DatasetNameSchema,
+    path: z.string().min(1),
     about: z.string().min(1).optional(),
     workflow: WorkflowIdSchema.optional(),
-    max_attempts: SourceWorkspaceMaxAttemptsSchema.optional(),
-    max_loops: SourceWorkspaceMaxLoopsSchema.optional(),
+    max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
+    max_loops: SourceCompiledMaxLoopsSchema.optional(),
     checks: z.array(SourceTruthCheckSchema).default([]),
 }).strict());
-export const WorkspaceInterfConfigSchema = z.preprocess((value) => {
+export const CompiledInterfConfigSchema = z.preprocess((value) => {
     if (!value || typeof value !== "object" || Array.isArray(value))
         return value;
     const raw = value;
     return {
         ...raw,
-        type: "workspace",
+        type: "compiled",
         source: raw.source ?? { path: "./raw" },
         checks: raw.checks ?? [],
     };
 }, z.object({
-    type: z.literal("workspace"),
-    name: z.string(),
+    type: z.literal("compiled"),
+    name: DatasetNameSchema,
     about: z.string().optional(),
     workflow: WorkflowIdSchema.optional(),
-    max_attempts: SourceWorkspaceMaxAttemptsSchema.optional(),
-    max_loops: SourceWorkspaceMaxLoopsSchema.optional(),
+    max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
+    max_loops: SourceCompiledMaxLoopsSchema.optional(),
     checks: z.array(SourceTruthCheckSchema).default([]),
     workflow_origin: z.object({
         selected: WorkflowIdSchema,
@@ -382,9 +419,10 @@ export const WorkspaceInterfConfigSchema = z.preprocess((value) => {
     source: z.object({
         path: z.string(),
         control_path: z.string().optional(),
+        dataset_path: z.string().optional(),
     }),
 }).passthrough());
-export const InterfConfigSchema = WorkspaceInterfConfigSchema;
+export const InterfConfigSchema = CompiledInterfConfigSchema;
 export const WorkflowImprovementLoopSummarySchema = z.object({
     variation: z.number().int().min(1),
     kind: z.enum(["baseline", "edited"]),
@@ -404,11 +442,11 @@ export const WorkflowImprovementContextSchema = z.object({
     target_name: z.string(),
     workflow_id: WorkflowIdSchema,
     loop_index: z.number().int().min(1),
-    max_loops: SourceWorkspaceMaxLoopsSchema,
-    max_attempts: SourceWorkspaceMaxAttemptsSchema,
+    max_loops: SourceCompiledMaxLoopsSchema,
+    max_attempts: SourceCompiledMaxAttemptsSchema,
     review_paths: z.object({
         workflow_root: z.string(),
-        workspace_runtime: z.string().nullable(),
+        compiled_runtime: z.string().nullable(),
         test_comparisons: z.string().nullable(),
         execution_shells: z.string().nullable(),
         test_runs: z.string().nullable(),
@@ -473,17 +511,17 @@ export const WorkflowImprovementRunLedgerSchema = z.object({
     run_id: z.string(),
     target_name: z.string(),
     workflow_id: WorkflowIdSchema,
-    max_loops: SourceWorkspaceMaxLoopsSchema,
-    max_attempts: SourceWorkspaceMaxAttemptsSchema,
+    max_loops: SourceCompiledMaxLoopsSchema,
+    max_attempts: SourceCompiledMaxAttemptsSchema,
     loops: z.array(WorkflowImprovementLoopRecordSchema),
 });
 export const SourceFolderConfigSchema = z.object({
-    workspaces: z.array(SourceWorkspaceConfigSchema).optional(),
+    datasets: z.array(SourceDatasetConfigSchema).optional(),
 }).strict().superRefine((value, ctx) => {
-    if ((value.workspaces?.length ?? 0) === 0) {
+    if ((value.datasets?.length ?? 0) === 0) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
-            message: "Source-folder config needs at least one workspace.",
+            message: "Interf project config needs at least one dataset.",
         });
     }
 });
@@ -544,7 +582,7 @@ export const TestTargetRunSchema = z.object({
     target_count: z.number(),
     results: z.array(TestTargetResultSchema),
 });
-export const TestRunModeSchema = z.enum(["raw", "workspace", "both"]);
+export const TestRunModeSchema = z.enum(["raw", "compiled", "both"]);
 export const TestRunTargetSummarySchema = z.object({
     label: z.string(),
     run_path: z.string(),
@@ -566,12 +604,13 @@ export const TestRunComparisonSchema = z.object({
     generated_at: z.string(),
     mode: TestRunModeSchema,
     source_path: z.string(),
-    workspace: z.object({
-        name: z.string(),
-        path: z.string(),
+    checks_fingerprint: z.string().min(1).optional(),
+    dataset: z.object({
+        name: DatasetNameSchema,
+        compiled_path: z.string().nullable(),
     }),
     raw: TestRunTargetSummarySchema.nullable(),
-    compiled_workspace: TestRunTargetSummarySchema.nullable(),
+    compiled: TestRunTargetSummarySchema.nullable(),
     summary: z.object({
         raw_pass_rate: z.number().nullable(),
         compiled_pass_rate: z.number().nullable(),

package/dist/lib/source-config.d.ts

@@ -1,35 +1,39 @@
-import { type InterfConfig, type TestSpec, type TestTargetType, type SourceTruthCheck, type SourceWorkspaceConfig, type SourceFolderConfig } from "./schema.js";
-export declare const SOURCE_FOLDER_CONFIG_FILE = "interf.config.json";
+import { type InterfConfig, type TestSpec, type TestTargetType, type SourceTruthCheck, type SourceDatasetConfig, type SourceFolderConfig } from "./schema.js";
+export declare const SOURCE_FOLDER_CONFIG_FILE = "interf.json";
 export interface LoadedSourceTestSpec extends TestSpec {
     id: string;
     filePath: string;
 }
+export declare function fingerprintTruthChecks(checks: SourceTruthCheck[]): string;
 export declare function loadSourceFolderConfig(sourcePath: string): SourceFolderConfig | null;
-export interface WritableSourceFolderConfig {
-    workspaces?: SourceWorkspaceConfig[];
+export interface WritableSourceProjectConfig {
+    datasets?: Array<Omit<SourceDatasetConfig, "path"> & {
+        path?: string;
+    }>;
 }
-export declare function listSourceWorkspaceConfigs(config: SourceFolderConfig | null): SourceWorkspaceConfig[];
-export declare function resolveWorkspaceCompileMaxAttempts(workspaceConfig: Pick<SourceWorkspaceConfig, "max_attempts">, override?: number | null): number | null;
-export declare function resolveWorkspaceCompileMaxLoops(workspaceConfig: Pick<SourceWorkspaceConfig, "max_loops">, override?: number | null): number | null;
-export declare function getDefaultSourceWorkspaceConfig(config: SourceFolderConfig | null): SourceWorkspaceConfig | null;
-export declare function findSourceWorkspaceConfig(config: SourceFolderConfig | null, workspaceName: string): SourceWorkspaceConfig | null;
-export declare function saveSourceFolderConfig(sourcePath: string, config: WritableSourceFolderConfig): void;
-export declare function appendSourceWorkspaceChecks(sourcePath: string, workspaceName: string, checks: SourceTruthCheck[]): void;
-export declare function upsertSourceWorkspaceConfig(sourcePath: string, workspaceConfig: SourceWorkspaceConfig, options?: {
+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 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?: {
     matchName?: string;
 }): void;
-export declare function workspaceMaxAttempts(maxAttempts: number | null | undefined): number | undefined;
-export declare function workspaceMaxLoops(maxLoops: number | null | undefined): number | undefined;
-export declare function sourceWorkspaceConfigFromInterfConfig(config: InterfConfig): SourceWorkspaceConfig;
-export declare function loadWorkspaceControlConfig(workspacePath: string): SourceWorkspaceConfig | null;
-export declare function saveWorkspaceInterfConfig(workspacePath: string, config: InterfConfig): InterfConfig;
-export declare function syncWorkspaceInterfConfigFromSourceWorkspaceConfig(workspacePath: string, workspaceConfig: SourceWorkspaceConfig): InterfConfig;
+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 saveCompiledInterfConfig(compiledPath: string, config: InterfConfig): InterfConfig;
+export declare function syncCompiledInterfConfigFromSourceDatasetConfig(compiledPath: string, datasetConfig: SourceDatasetConfig): InterfConfig;
 export declare function buildTestSpecFromSourceFolderConfig(options: {
     sourcePath: string;
     targetName?: string | null;
     targetType?: TestTargetType;
 }): LoadedSourceTestSpec | null;
-export declare function buildTestSpecFromWorkspaceConfig(options: {
-    workspacePath: string;
+export declare function buildTestSpecFromCompiledDatasetConfig(options: {
+    compiledPath: string;
     targetType?: TestTargetType;
 }): LoadedSourceTestSpec | null;
+export declare function resolveSourceDatasetPath(projectPath: string, datasetConfig: Pick<SourceDatasetConfig, "path">): string;