@interf/compiler 0.6.1 → 0.6.3

package/dist/lib/schema.js

@@ -1,542 +1,6 @@
-import { z } from "zod";
-import { COMPILED_ZONE_KINDS, } from "./workflow-primitives.js";
-const JsonRecordSchema = z.record(z.string(), z.unknown());
-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) => COMPILED_RELATIVE_PATH_SEGMENT.test(segment));
-}
-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.string().regex(WorkflowIdPattern);
-export const WorkflowIdSchema = z.string().regex(WorkflowIdPattern);
-export const WorkflowZoneIdSchema = z.string().regex(WorkflowIdPattern);
-export const WorkflowCompiledZoneKindSchema = z.enum(COMPILED_ZONE_KINDS);
-export const WorkflowZoneRoleSchema = z.enum(["input", "working", "output", "runtime"]);
-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()),
-    stages: z.record(z.string().regex(WorkflowIdPattern), CompiledStageStateSchema).optional(),
-    last_add: z.string().nullable().optional(),
-    last_compile: z.string().nullable().optional(),
-    warning_count: z.number().optional(),
-    error_count: z.number().optional(),
-}).strict();
-export const ViewSectionSchema = z.object({
-    id: z.string(),
-    type: z.enum(["status", "cards", "graph", "documents", "table"]),
-    title: z.string(),
-    path: z.string().optional(),
-    paths: z.array(z.string()).optional(),
-});
-export const ViewCardSchema = z.object({
-    id: z.string(),
-    label: z.string(),
-    metric: z.string(),
-    denominator_metric: z.string().optional(),
-    format: z.enum(["number", "fraction", "timestamp"]),
-});
-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.union([
-        z.enum(["idle", "compiled", "failed"]),
-        RuntimeStageSchema,
-    ]),
-    summary: z.string(),
-    metrics: z.record(z.string(), z.number()),
-    checks: z.record(z.string(), z.boolean()),
-});
-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().nullable(),
-    graph_scope: z.array(z.string()),
-    cards: z.array(ViewCardSchema),
-    sections: z.array(ViewSectionSchema),
-});
-export const CompiledRawSnapshotSchema = z.object({
-    kind: z.literal("compiled-raw-snapshot"),
-    version: z.literal(1),
-    generated_at: z.string(),
-    target_name: z.string(),
-    source_root: z.string(),
-    raw_root: z.string(),
-    source_total: z.number(),
-    sample_files: z.array(z.string()),
-});
-export const WorkflowPurposeSchema = z.object({
-    label: z.string().min(1),
-    task_hint: z.string().min(1),
-}).strict();
-export const WorkflowZoneSchema = z.object({
-    id: WorkflowZoneIdSchema,
-    role: WorkflowZoneRoleSchema,
-    path: z.string().min(1).refine(isCompiledRelativePath, {
-        message: "Zone paths must stay inside the compiled root",
-    }),
-    kind: WorkflowCompiledZoneKindSchema,
-    required: z.boolean(),
-    owned_by: z.array(z.string().regex(WorkflowIdPattern)),
-    description: z.string().min(1),
-});
-export const WorkflowCompiledZoneSchema = WorkflowZoneSchema;
-export const WorkflowSchemaSchema = z.object({
-    kind: z.literal("workflow-schema"),
-    version: z.literal(1),
-    target_type: z.literal("compiled"),
-    label: z.string().min(1),
-    zones: z.array(WorkflowZoneSchema).min(1),
-});
-export const WorkflowCompiledSchemaSchema = WorkflowSchemaSchema;
-export const WorkflowCompilerApiSchema = z.object({
-    kind: z.literal("compiled"),
-    version: z.literal(1),
-});
-export const WorkflowStageZoneAccessSchema = z.array(WorkflowZoneIdSchema).min(1);
-export const ExecutionShellZoneMountSchema = z.object({
-    zone_id: WorkflowZoneIdSchema,
-    compiled_path: z.string(),
-    shell_root_path: z.string(),
-    input_mount_path: z.string().nullable(),
-    output_mount_path: z.string().nullable(),
-});
-export const ExecutionShellPathsSchema = z.object({
-    kind: z.literal("interf-execution-shell"),
-    version: z.literal(1),
-    workflow: WorkflowIdSchema,
-    stage: RuntimeStageSchema,
-    reads: z.array(ExecutionShellZoneMountSchema),
-    writes: z.array(ExecutionShellZoneMountSchema),
-});
-export const RuntimeExecutorInfoSchema = z.object({
-    kind: z.enum(["local-agent", "connected-provider", "managed"]),
-    name: z.string(),
-    display_name: z.string(),
-    command: z.string().nullable(),
-    model: z.string().nullable().optional(),
-    effort: z.string().nullable().optional(),
-    profile: z.string().nullable().optional(),
-    timeout_ms: z.number().nullable().optional(),
-});
-export const RuntimeStageInstructionsSchema = 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()),
-}).strict();
-export const RuntimeStageAcceptanceSchema = z.object({
-    artifacts_exist: z.array(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(),
-    frontmatter_required_keys_in_zones: z.record(WorkflowZoneIdSchema, z.array(z.string().min(1)).min(1)).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(),
-}).strict();
-export const RuntimeStageContractSchema = z.object({
-    kind: z.literal("interf-stage-contract"),
-    version: z.literal(1),
-    generated_at: z.string(),
-    run_id: z.string(),
-    target_type: RuntimeTargetTypeSchema,
-    target_name: z.string(),
-    workflow: z.object({
-        id: WorkflowIdSchema,
-        stage_index: z.number().nullable(),
-        stage_total: z.number(),
-        stages: z.array(RuntimeStageSchema),
-    }),
-    stage: RuntimeStageSchema,
-    stage_label: z.string(),
-    contract_type: RuntimeContractTypeSchema,
-    executor: RuntimeExecutorInfoSchema,
-    instructions: RuntimeStageInstructionsSchema,
-    counts: z.record(z.string(), z.number()),
-    acceptance: RuntimeStageAcceptanceSchema.optional(),
-    artifacts: z.object({
-        reads: z.array(z.string()),
-        writes: z.array(z.string()),
-        verifies: z.array(z.string()).optional(),
-    }),
-    policies: z.object({
-        execution_mode: z.literal("deterministic"),
-        status_prefixes: z.array(z.string()),
-        notes: z.array(z.string()),
-        evidence_weighting: z.object({
-            required_fields: z.array(z.string()),
-            preserve_tiers: z.boolean(),
-        }).optional(),
-        working_set: z.object({
-            target_context_fraction: z.number(),
-            strategy: z.string(),
-        }).optional(),
-    }),
-});
-export const RuntimeRunSchema = z.object({
-    kind: z.literal("interf-run"),
-    version: z.literal(1),
-    run_id: z.string(),
-    target_type: RuntimeTargetTypeSchema,
-    target_name: z.string(),
-    workflow: WorkflowIdSchema,
-    stage: RuntimeStageSchema,
-    stage_label: z.string(),
-    contract_type: RuntimeContractTypeSchema,
-    status: z.enum(["running", "succeeded", "failed"]),
-    executor: RuntimeExecutorInfoSchema,
-    started_at: z.string(),
-    updated_at: z.string(),
-    finished_at: z.string().nullable(),
-    contract_path: z.string(),
-    execution_path: z.string().optional(),
-    counts: z.record(z.string(), z.number()),
-    output_artifacts: z.array(z.string()),
-    logs: z.object({
-        prompt_path: z.string(),
-        event_stream_path: z.string(),
-        status_path: z.string().optional(),
-    }).optional(),
-    summary: z.string(),
-    exit_code: z.number().nullable(),
-    error: z.string().nullable(),
-});
-export const CompiledInventoryEntrySchema = z.object({
-    input_zone: WorkflowZoneIdSchema.optional(),
-    input_path: z.string().min(1).optional(),
-    output_zone: WorkflowZoneIdSchema,
-    output_path: z.string().min(1),
-    state: z.string().min(1).optional(),
-    metadata: JsonRecordSchema.optional(),
-}).strict();
-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(),
-    must_not_include: z.array(z.string().min(1)).optional(),
-    min_words: z.number().int().nonnegative().optional(),
-    max_words: z.number().int().nonnegative().optional(),
-}).refine((value) => value.min_words === undefined ||
-    value.max_words === undefined ||
-    value.max_words >= value.min_words, {
-    message: "max_words must be greater than or equal to min_words",
-}).refine((value) => (value.must_include?.length ?? 0) > 0 ||
-    (value.must_include_one_of?.length ?? 0) > 0 ||
-    (value.must_not_include?.length ?? 0) > 0 ||
-    value.min_words !== undefined ||
-    value.max_words !== undefined, {
-    message: "Test expectations must include at least one check",
-});
-const TestCaseCoreSchema = z.object({
-    id: z.string().regex(/^[a-z0-9][a-z0-9-]{0,79}$/),
-    question: z.string().min(1),
-    file: z.string().min(1).optional(),
-    answer: z.string().min(1).optional(),
-    expect: TestCaseExpectSchema.optional(),
-    strictness: z.string().min(1).optional(),
-}).superRefine((value, ctx) => {
-    if (!value.file && !value.answer && !value.expect) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "Test cases need at least one of file, answer, or expect.",
-        });
-    }
-});
-export const TestCaseSchema = TestCaseCoreSchema;
-const TestSpecCoreSchema = z.object({
-    type: TestTargetTypeSchema,
-    name: z.string().min(1),
-    description: z.string().min(1).optional(),
-    cases: z.array(TestCaseSchema).min(1),
-});
-export const TestSpecSchema = TestSpecCoreSchema;
-export const SourceTruthCheckSchema = z.object({
-    id: z.string().regex(WorkflowIdPattern).optional(),
-    question: z.string().min(1),
-    answer: z.string().min(1).optional(),
-    expect: TestCaseExpectSchema.optional(),
-    strictness: z.string().min(1).optional(),
-}).strict().superRefine((value, ctx) => {
-    if (!value.answer && !value.expect) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            path: ["answer"],
-            message: "Truth checks need `answer` or `expect`.",
-        });
-    }
-});
-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.object({
-    id: z.string().regex(WorkflowIdPattern).optional(),
-    name: DatasetNameSchema,
-    path: z.string().min(1).default("."),
-    about: z.string().min(1).optional(),
-    workflow: WorkflowIdSchema.optional(),
-    max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
-    max_loops: SourceCompiledMaxLoopsSchema.optional(),
-    checks: z.array(SourceTruthCheckSchema).default([]),
-}).strict();
-export const CompiledInterfConfigSchema = z.object({
-    type: z.literal("compiled"),
-    name: DatasetNameSchema,
-    about: z.string().optional(),
-    workflow: WorkflowIdSchema,
-    max_attempts: SourceCompiledMaxAttemptsSchema.optional(),
-    max_loops: SourceCompiledMaxLoopsSchema.optional(),
-    checks: z.array(SourceTruthCheckSchema).default([]),
-    workflow_origin: z.object({
-        selected: WorkflowIdSchema,
-        local_draft: z.boolean().optional(),
-    }).optional(),
-    source: z.object({
-        path: z.string(),
-        control_path: z.string().optional(),
-        dataset_path: z.string(),
-    }),
-}).passthrough();
-export const InterfConfigSchema = CompiledInterfConfigSchema;
-export const WorkflowImprovementLoopSummarySchema = z.object({
-    variation: z.number().int().min(1),
-    kind: z.enum(["baseline", "edited"]),
-    attempts_run: z.number().int().min(1),
-    passed: z.boolean(),
-    passed_questions: z.number().int().min(0),
-    total_questions: z.number().int().min(0),
-    failed_stage: z.string().nullable().optional(),
-    test_run_path: z.string().nullable().optional(),
-    test_sandbox_path: z.string().nullable().optional(),
-    summary: z.string().min(1),
-});
-export const WorkflowImprovementContextSchema = z.object({
-    kind: z.literal("interf-workflow-improvement-loop"),
-    version: z.literal(1),
-    generated_at: z.string(),
-    target_name: z.string(),
-    workflow_id: WorkflowIdSchema,
-    loop_index: z.number().int().min(1),
-    max_loops: SourceCompiledMaxLoopsSchema,
-    max_attempts: SourceCompiledMaxAttemptsSchema,
-    review_paths: z.object({
-        workflow_root: z.string(),
-        compiled_runtime: z.string().nullable(),
-        test_comparisons: z.string().nullable(),
-        execution_shells: z.string().nullable(),
-        test_runs: z.string().nullable(),
-        test_sandboxes: z.string().nullable(),
-    }),
-    truth_checks: z.object({
-        count: z.number().int().min(0),
-        questions: z.array(z.object({
-            id: z.string(),
-            question: z.string(),
-        })),
-    }),
-    previous_variations: z.array(WorkflowImprovementLoopSummarySchema),
-    latest_failure: WorkflowImprovementLoopSummarySchema.nullable(),
-});
-export const PreservedShellTypeSchema = z.enum([
-    "stage-execution",
-    "workflow-improvement",
-]);
-export const PreservedShellSnapshotSchema = z.object({
-    kind: z.literal("interf-preserved-shell"),
-    version: z.literal(1),
-    shell_type: PreservedShellTypeSchema,
-    generated_at: z.string(),
-    root_path: z.string(),
-    materialized_symlinks: z.number().int().min(0),
-});
-export const WorkflowPackageValidationSchema = z.object({
-    ok: z.boolean(),
-    summary: z.string(),
-    errors: z.array(z.string()),
-    counts: z.record(z.string(), z.number()),
-});
-export const WorkflowImprovementLoopRecordSchema = z.object({
-    kind: z.literal("interf-workflow-improvement-loop-record"),
-    version: z.literal(1),
-    recorded_at: z.string(),
-    run_id: z.string(),
-    loop_index: z.number().int().min(1),
-    target_name: z.string(),
-    workflow_id: WorkflowIdSchema,
-    result: z.enum(["updated", "no-change", "invalid", "executor-failed"]),
-    changed: z.boolean(),
-    applied: z.boolean(),
-    summary: z.string(),
-    shell_path: z.string(),
-    loop_root_path: z.string(),
-    context_path: z.string(),
-    workflow_before_path: z.string(),
-    workflow_after_path: z.string(),
-    prompt_log_path: z.string(),
-    event_log_path: z.string(),
-    status_log_path: z.string(),
-    preserved_shell_manifest_path: z.string().nullable(),
-    validation: WorkflowPackageValidationSchema.nullable(),
-});
-export const WorkflowImprovementRunLedgerSchema = z.object({
-    kind: z.literal("interf-workflow-improvement-run"),
-    version: z.literal(1),
-    generated_at: z.string(),
-    updated_at: z.string(),
-    run_id: z.string(),
-    target_name: z.string(),
-    workflow_id: WorkflowIdSchema,
-    max_loops: SourceCompiledMaxLoopsSchema,
-    max_attempts: SourceCompiledMaxAttemptsSchema,
-    loops: z.array(WorkflowImprovementLoopRecordSchema),
-});
-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.",
-        });
-    }
-});
-export const TestCheckResultSchema = z.object({
-    label: z.string(),
-    ok: z.boolean(),
-    detail: z.string(),
-});
-export const TestCaseResultSchema = z.object({
-    caseId: z.string(),
-    question: z.string(),
-    file: z.string().optional(),
-    ok: z.boolean(),
-    wordCount: z.number(),
-    passedChecks: z.number(),
-    totalChecks: z.number(),
-    checks: z.array(TestCheckResultSchema),
-    answer: z.string().optional(),
-    trace: JsonRecordSchema.nullable().optional(),
-});
-export const TestTargetResultSchema = z.object({
-    target: z.object({
-        type: TestTargetTypeSchema,
-        name: z.string(),
-        path: z.string(),
-        workflow: z.string(),
-    }),
-    sandbox_path: z.string().optional(),
-    ok: z.boolean(),
-    passedCases: z.number(),
-    totalCases: z.number(),
-    passedChecks: z.number(),
-    totalChecks: z.number(),
-    caseResults: z.array(TestCaseResultSchema),
-});
-export const TestTargetRunSchema = z.object({
-    kind: z.literal("interf-test-target-run"),
-    version: z.literal(1),
-    generated_at: z.string(),
-    spec: z.object({
-        id: z.string(),
-        name: z.string(),
-        type: TestTargetTypeSchema,
-        file: z.string(),
-        description: z.string().optional(),
-        case_count: z.number(),
-        cases: z.array(z.object({
-            id: z.string(),
-            question: z.string(),
-            file: z.string().optional(),
-            answer: z.string().optional(),
-            strictness: z.string().optional(),
-            expect: TestCaseExpectSchema.optional(),
-        })),
-    }),
-    source_path: z.string(),
-    executor: RuntimeExecutorInfoSchema.optional(),
-    target_count: z.number(),
-    results: z.array(TestTargetResultSchema),
-});
-export const TestRunModeSchema = z.enum(["raw", "compiled", "both"]);
-export const TestRunTargetSummarySchema = z.object({
-    label: z.string(),
-    run_path: z.string(),
-    ok: z.boolean(),
-    passed_cases: z.number(),
-    total_cases: z.number(),
-    passed_checks: z.number(),
-    total_checks: z.number(),
-    target: z.object({
-        type: TestTargetTypeSchema,
-        name: z.string(),
-        path: z.string(),
-        workflow: z.string(),
-    }),
-});
-export const TestRunComparisonSchema = z.object({
-    kind: z.literal("interf-test-run"),
-    version: z.literal(1),
-    generated_at: z.string(),
-    mode: TestRunModeSchema,
-    source_path: z.string(),
-    checks_fingerprint: z.string().min(1).optional(),
-    dataset: z.object({
-        name: DatasetNameSchema,
-        compiled_path: z.string().nullable(),
-    }),
-    raw: TestRunTargetSummarySchema.nullable(),
-    compiled: TestRunTargetSummarySchema.nullable(),
-    summary: z.object({
-        raw_pass_rate: z.number().nullable(),
-        compiled_pass_rate: z.number().nullable(),
-        pass_rate_delta: z.number().nullable(),
-    }),
-});
-export const InterfUserConfigSchema = z.object({
-    agent: z.string(),
-    agentCommand: z.string(),
-    skillsInstalled: z.boolean(),
-    initialized: z.string(),
-});
+// Compatibility barrel for historical `src/lib/schema.ts` imports.
+// Source-of-truth schemas live in package-owned modules under `src/packages/*/lib/schema.ts`.
+export * from "../packages/compiler/lib/schema.js";
+export * from "../packages/project-model/lib/schema.js";
+export * from "../packages/testing/lib/schema.js";
+export * from "../packages/agents/lib/schema.js";

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

@@ -1,39 +1 @@
-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 WritableSourceProjectConfig {
-    datasets?: Array<Omit<SourceDatasetConfig, "path"> & {
-        path?: string;
-    }>;
-}
-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 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 buildTestSpecFromCompiledDatasetConfig(options: {
-    compiledPath: string;
-    targetType?: TestTargetType;
-}): LoadedSourceTestSpec | null;
-export declare function resolveSourceDatasetPath(projectPath: string, datasetConfig: Pick<SourceDatasetConfig, "path">): string;
+export * from "../packages/project-model/source-config.js";