@interf/compiler 0.3.4 → 0.4.0

package/dist/lib/test-matrices.js

@@ -0,0 +1,96 @@
+import { z } from "zod";
+import { WorkflowIdPattern } from "./schema.js";
+import { TestProfilePresetIdSchema, resolveTestProfilePreset, } from "./test-profile-presets.js";
+export const TestMatrixAgentSchema = z.enum(["claude-code", "codex"]);
+const TestMatrixProfileInputSchema = z.object({
+    id: z.string().regex(WorkflowIdPattern),
+    preset: TestProfilePresetIdSchema.optional(),
+    agent: TestMatrixAgentSchema.optional(),
+    model: z.string().min(1).optional(),
+    profile: z.string().min(1).optional(),
+    effort: z.string().min(1).optional(),
+    timeout_ms: z.number().int().positive().optional(),
+}).superRefine((value, ctx) => {
+    if (!value.preset && !value.agent) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["agent"],
+            message: "Test-matrix profiles need either `agent` or `preset`.",
+        });
+    }
+    if (value.preset) {
+        for (const field of ["agent", "model", "profile", "effort", "timeout_ms"]) {
+            if (value[field] !== undefined) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: [field],
+                    message: `Test profile presets own \`${field}\`; remove the inline override or stop using \`preset\`.`,
+                });
+            }
+        }
+    }
+});
+export const TestMatrixProfileSchema = TestMatrixProfileInputSchema.transform((value) => {
+    if (!value.preset) {
+        return {
+            ...value,
+            agent: value.agent,
+        };
+    }
+    const preset = resolveTestProfilePreset(value.preset);
+    return {
+        ...value,
+        agent: preset.agent,
+        model: preset.model,
+        profile: preset.profile,
+        effort: preset.effort,
+        timeout_ms: preset.timeout_ms,
+    };
+});
+export const TestMatrixRetryPolicySchema = z.object({
+    max_attempts_per_profile: z.number().int().min(1).max(5).optional(),
+});
+export const TestMatrixWorkspaceSchema = z.string().regex(WorkflowIdPattern);
+export const TestMatrixSchema = z.object({
+    id: z.string().regex(WorkflowIdPattern),
+    name: z.string().min(1),
+    source_path: z.string().min(1),
+    compile_profiles: z.array(TestMatrixProfileSchema).min(1),
+    retry_policy: TestMatrixRetryPolicySchema.optional(),
+    workspaces: z.array(TestMatrixWorkspaceSchema).min(1),
+}).superRefine((value, ctx) => {
+    const duplicateProfileIds = findDuplicates(value.compile_profiles.map((profile) => profile.id));
+    for (const id of duplicateProfileIds) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["compile_profiles"],
+            message: `Duplicate compile profile id in test matrix: ${id}`,
+        });
+    }
+    const duplicateWorkspaceIds = findDuplicates(value.workspaces);
+    for (const id of duplicateWorkspaceIds) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["workspaces"],
+            message: `Duplicate workspace name in test matrix: ${id}`,
+        });
+    }
+});
+function findDuplicates(values) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const value of values) {
+        if (seen.has(value))
+            duplicates.add(value);
+        seen.add(value);
+    }
+    return Array.from(duplicates.values()).sort();
+}
+export function testMatrixProfileToExecutionProfile(profile) {
+    return {
+        model: profile.model ?? null,
+        profile: profile.profile ?? null,
+        effort: profile.effort ?? null,
+        timeoutMs: profile.timeout_ms ?? null,
+    };
+}

package/dist/lib/test-paths.d.ts

@@ -0,0 +1,12 @@
+import type { TestTargetType } from "./test-types.js";
+export declare const TEST_SPEC_EXTENSIONS: Set<string>;
+export declare function testSpecRootPath(sourcePath: string): string;
+export declare function testSpecTypePath(sourcePath: string, type: TestTargetType): string;
+export declare function targetTestRunsPath(workspacePath: string, type: TestTargetType): string;
+export declare function targetTestRunGitignorePath(workspacePath: string, type: TestTargetType): string;
+export declare function targetTestSandboxesPath(workspacePath: string, type: TestTargetType): string;
+export declare function targetTestSandboxGitignorePath(workspacePath: string, type: TestTargetType): string;
+export declare function testSpecFilePath(sourcePath: string, type: TestTargetType, id: string): string;
+export declare function normalizeTestId(input: string): string;
+export declare function assertTestId(id: string): void;
+export declare function assertWritableTestSpecPath(filePath: string): void;

package/dist/lib/test-paths.js

@@ -0,0 +1,44 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { targetTestRunsRootForWorkspace, targetTestSandboxesRootForWorkspace, } from "./workspace-paths.js";
+const TEST_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,79}$/;
+export const TEST_SPEC_EXTENSIONS = new Set([".json"]);
+export function testSpecRootPath(sourcePath) {
+    return join(sourcePath, "interf", "tests");
+}
+export function testSpecTypePath(sourcePath, type) {
+    return join(testSpecRootPath(sourcePath), type);
+}
+export function targetTestRunsPath(workspacePath, type) {
+    return join(targetTestRunsRootForWorkspace(workspacePath), type);
+}
+export function targetTestRunGitignorePath(workspacePath, type) {
+    return join(targetTestRunsPath(workspacePath, type), ".gitignore");
+}
+export function targetTestSandboxesPath(workspacePath, type) {
+    return join(targetTestSandboxesRootForWorkspace(workspacePath), type);
+}
+export function targetTestSandboxGitignorePath(workspacePath, type) {
+    return join(targetTestSandboxesPath(workspacePath, type), ".gitignore");
+}
+export function testSpecFilePath(sourcePath, type, id) {
+    return join(testSpecTypePath(sourcePath, type), `${id}.json`);
+}
+export function normalizeTestId(input) {
+    return input
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 80);
+}
+export function assertTestId(id) {
+    if (!TEST_ID_PATTERN.test(id)) {
+        throw new Error(`Invalid test id: ${id}`);
+    }
+}
+export function assertWritableTestSpecPath(filePath) {
+    if (existsSync(filePath)) {
+        throw new Error(`Test spec already exists: ${filePath}`);
+    }
+}

package/dist/lib/test-profile-presets.d.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+declare const TestProfilePresetValueSchema: z.ZodObject<{
+    agent: z.ZodEnum<{
+        "claude-code": "claude-code";
+        codex: "codex";
+    }>;
+    model: z.ZodOptional<z.ZodString>;
+    profile: z.ZodOptional<z.ZodString>;
+    effort: z.ZodOptional<z.ZodString>;
+    timeout_ms: z.ZodOptional<z.ZodNumber>;
+    label: z.ZodString;
+}, z.core.$strip>;
+export declare const TestProfilePresetIds: readonly ["release-claude-high", "release-codex-high", "tier1-max-claude", "tier1-max-codex"];
+export declare const TestProfilePresetIdSchema: z.ZodEnum<{
+    "release-claude-high": "release-claude-high";
+    "release-codex-high": "release-codex-high";
+    "tier1-max-claude": "tier1-max-claude";
+    "tier1-max-codex": "tier1-max-codex";
+}>;
+export declare const TestProfilePresets: {
+    readonly "release-claude-high": {
+        agent: "claude-code" | "codex";
+        label: string;
+        model?: string | undefined;
+        profile?: string | undefined;
+        effort?: string | undefined;
+        timeout_ms?: number | undefined;
+    };
+    readonly "release-codex-high": {
+        agent: "claude-code" | "codex";
+        label: string;
+        model?: string | undefined;
+        profile?: string | undefined;
+        effort?: string | undefined;
+        timeout_ms?: number | undefined;
+    };
+    readonly "tier1-max-claude": {
+        agent: "claude-code" | "codex";
+        label: string;
+        model?: string | undefined;
+        profile?: string | undefined;
+        effort?: string | undefined;
+        timeout_ms?: number | undefined;
+    };
+    readonly "tier1-max-codex": {
+        agent: "claude-code" | "codex";
+        label: string;
+        model?: string | undefined;
+        profile?: string | undefined;
+        effort?: string | undefined;
+        timeout_ms?: number | undefined;
+    };
+};
+export type TestProfilePresetId = z.infer<typeof TestProfilePresetIdSchema>;
+export type TestProfilePresetValue = z.infer<typeof TestProfilePresetValueSchema>;
+export declare function resolveTestProfilePreset(id: TestProfilePresetId): TestProfilePresetValue;
+export {};

package/dist/lib/test-profile-presets.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+const TestProfilePresetAgentSchema = z.enum(["claude-code", "codex"]);
+const TestProfilePresetValueSchema = z.object({
+    agent: TestProfilePresetAgentSchema,
+    model: z.string().min(1).optional(),
+    profile: z.string().min(1).optional(),
+    effort: z.string().min(1).optional(),
+    timeout_ms: z.number().int().positive().optional(),
+    label: z.string().min(1),
+});
+export const TestProfilePresetIds = [
+    "release-claude-high",
+    "release-codex-high",
+    "tier1-max-claude",
+    "tier1-max-codex",
+];
+export const TestProfilePresetIdSchema = z.enum(TestProfilePresetIds);
+export const TestProfilePresets = {
+    "release-claude-high": TestProfilePresetValueSchema.parse({
+        agent: "claude-code",
+        model: "claude-sonnet-4-6",
+        effort: "high",
+        timeout_ms: 480000,
+        label: "Claude Code (Claude Sonnet 4.6, high)",
+    }),
+    "release-codex-high": TestProfilePresetValueSchema.parse({
+        agent: "codex",
+        model: "gpt-5.4-mini",
+        effort: "high",
+        timeout_ms: 480000,
+        label: "Codex (GPT-5.4 Mini, high)",
+    }),
+    "tier1-max-claude": TestProfilePresetValueSchema.parse({
+        agent: "claude-code",
+        model: "claude-opus-4-6[1m]",
+        effort: "max",
+        timeout_ms: 480000,
+        label: "Claude Code (Claude Opus 4.6 1M, max)",
+    }),
+    "tier1-max-codex": TestProfilePresetValueSchema.parse({
+        agent: "codex",
+        model: "gpt-5.4",
+        effort: "xhigh",
+        timeout_ms: 480000,
+        label: "Codex (GPT-5.4, xhigh)",
+    }),
+};
+export function resolveTestProfilePreset(id) {
+    return TestProfilePresets[id];
+}

package/dist/lib/test-sandbox.d.ts

@@ -0,0 +1,11 @@
+import type { TestTargetCandidate } from "./test-types.js";
+export type TestSandboxRetentionMode = "on-failure" | "always";
+export interface TestSandbox {
+    rootPath: string;
+    rawPath: string;
+    targetPath: string;
+    workspacePath: string | null;
+    preserve(destinationPath: string): string;
+    cleanup(): void;
+}
+export declare function createTestSandbox(target: TestTargetCandidate): TestSandbox;

package/dist/lib/{benchmark-sandbox.js → test-sandbox.js}

@@ -1,26 +1,30 @@
-import { cpSync, existsSync, mkdirSync, mkdtempSync, renameSync, rmSync, writeFileSync, } from "node:fs";
+import { cpSync, existsSync, mkdirSync, mkdtempSync, renameSync, rmSync, } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join, relative, sep } from "node:path";
 import { refreshWorkspaceBootstrapGuidance } from "./interf-bootstrap.js";
 import { readInterfConfig, resolveSourceControlPath, resolveWorkspaceRawPath } from "./interf.js";
+import { projectRawTestQueryShell } from "./agent-shells.js";
+import { saveWorkspaceInterfConfig } from "./source-config.js";
 import { refreshWorkspaceArtifacts } from "./state.js";
 import { projectRawSnapshot } from "./workspace-raw.js";
+import { testRootForWorkspace, stageExecutionShellsRoot, targetTestSandboxesRootForWorkspace, workflowImprovementLoopsRoot, workspaceQueryAcceptanceRoot, workspaceRuntimeLogsRoot, } from "./workspace-paths.js";
 function toPortableRelativePath(fromPath, toPath) {
     return relative(fromPath, toPath).split(sep).join("/");
 }
-function writeWorkspaceConfig(workspacePath, config) {
-    writeFileSync(join(workspacePath, "interf.json"), `${JSON.stringify(config, null, 2)}\n`);
-}
 function sanitizeWorkspaceArtifacts(workspacePath) {
-    for (const relativePath of [
-        ".interf/logs",
-        ".interf/query-acceptance",
+    for (const absolutePath of [
+        testRootForWorkspace(workspacePath),
+        targetTestSandboxesRootForWorkspace(workspacePath),
+        stageExecutionShellsRoot(workspacePath),
+        workflowImprovementLoopsRoot(workspacePath),
+        workspaceRuntimeLogsRoot(workspacePath),
+        workspaceQueryAcceptanceRoot(workspacePath),
     ]) {
-        rmSync(join(workspacePath, relativePath), { recursive: true, force: true });
+        rmSync(absolutePath, { recursive: true, force: true });
     }
 }
-export function createBenchmarkSandbox(target) {
-    let sandboxRoot = mkdtempSync(join(tmpdir(), "interf-benchmark-sandbox-"));
+export function createTestSandbox(target) {
+    let sandboxRoot = mkdtempSync(join(tmpdir(), "interf-test-sandbox-"));
     let preserved = false;
     const sandboxWorkspacePath = () => (target.type === "workspace"
         ? join(sandboxRoot, "interf", "workspaces", target.name)
@@ -30,7 +34,7 @@ export function createBenchmarkSandbox(target) {
         : join(sandboxRoot, "raw"));
     const sandboxTargetPath = () => (target.type === "workspace"
         ? join(sandboxRoot, "interf", "workspaces", target.name)
-        : join(sandboxRoot, "raw"));
+        : sandboxRoot);
     try {
         if (target.type === "workspace") {
             mkdirSync(dirname(sandboxTargetPath()), { recursive: true });
@@ -51,8 +55,9 @@ export function createBenchmarkSandbox(target) {
                     preserveTimestamps: false,
                 });
             }
-            writeWorkspaceConfig(sandboxTargetPath(), {
+            saveWorkspaceInterfConfig(sandboxTargetPath(), {
                 ...sandboxConfig,
+                checks: [],
                 source: {
                     path: toPortableRelativePath(sandboxTargetPath(), sandboxRawPath()),
                 },
@@ -69,6 +74,7 @@ export function createBenchmarkSandbox(target) {
                 prune: false,
                 preserveTimestamps: false,
             });
+            projectRawTestQueryShell(sandboxTargetPath());
         }
     }
     catch (error) {
@@ -103,4 +109,3 @@ export function createBenchmarkSandbox(target) {
         },
     };
 }
-//# sourceMappingURL=benchmark-sandbox.js.map

package/dist/lib/test-specs.d.ts

@@ -0,0 +1,7 @@
+import type { TestSpec, TestTargetType, LoadedTestSpec } from "./test-types.js";
+export declare function listTestSpecs(sourcePath: string, type: TestTargetType): LoadedTestSpec[];
+export declare function loadTestSpec(sourcePath: string, type: TestTargetType, id: string): LoadedTestSpec | null;
+export declare function loadTestSpecFromFile(filePath: string): LoadedTestSpec | null;
+export declare function writeTestSpec(sourcePath: string, spec: TestSpec & {
+    id?: string;
+}): string;

package/dist/lib/test-specs.js

@@ -0,0 +1,114 @@
+import { existsSync, mkdirSync, readdirSync, writeFileSync, } from "node:fs";
+import { basename, extname, join } from "node:path";
+import { readJsonFileWithSchema } from "./parse.js";
+import { TestSpecSchema } from "./schema.js";
+import { TEST_SPEC_EXTENSIONS, assertTestId, assertWritableTestSpecPath, testSpecFilePath, testSpecTypePath, normalizeTestId, } from "./test-paths.js";
+function readTestSpecFile(filePath) {
+    const extension = extname(filePath).toLowerCase();
+    if (!TEST_SPEC_EXTENSIONS.has(extension))
+        return null;
+    const parsed = readJsonFileWithSchema(filePath, "test spec", TestSpecSchema);
+    if (!parsed)
+        return null;
+    return {
+        ...parsed,
+        id: basename(filePath, extension),
+        filePath,
+    };
+}
+function serializeTestSpec(spec) {
+    return {
+        type: spec.type,
+        name: spec.name,
+        ...(spec.description ? { description: spec.description } : {}),
+        checks: spec.cases.map((testCase) => ({
+            id: testCase.id,
+            question: testCase.question,
+            ...(testCase.file ? { file: testCase.file } : {}),
+            ...(testCase.answer ? { answer: testCase.answer } : {}),
+            ...(testCase.strictness ? { strictness: testCase.strictness } : {}),
+            ...(testCase.expect ? { expect: testCase.expect } : {}),
+        })),
+    };
+}
+export function listTestSpecs(sourcePath, type) {
+    const dirPath = testSpecTypePath(sourcePath, type);
+    if (!existsSync(dirPath))
+        return [];
+    return readdirSync(dirPath)
+        .map((entry) => join(dirPath, entry))
+        .filter((filePath) => TEST_SPEC_EXTENSIONS.has(extname(filePath).toLowerCase()))
+        .map((filePath) => readTestSpecFile(filePath))
+        .filter((value) => value !== null)
+        .sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
+}
+export function loadTestSpec(sourcePath, type, id) {
+    const normalizedId = normalizeTestId(id);
+    const filePath = join(testSpecTypePath(sourcePath, type), `${normalizedId}.json`);
+    if (!existsSync(filePath))
+        return null;
+    return readTestSpecFile(filePath);
+}
+export function loadTestSpecFromFile(filePath) {
+    return readTestSpecFile(filePath);
+}
+export function writeTestSpec(sourcePath, spec) {
+    const id = normalizeTestId(spec.id ?? spec.name);
+    assertTestId(id);
+    const dirPath = testSpecTypePath(sourcePath, spec.type);
+    mkdirSync(dirPath, { recursive: true });
+    const existingPath = join(dirPath, `${id}.json`);
+    if (existsSync(existingPath)) {
+        throw new Error(`Test spec already exists: ${existingPath}`);
+    }
+    const filePath = testSpecFilePath(sourcePath, spec.type, id);
+    assertWritableTestSpecPath(filePath);
+    const normalizedSpec = {
+        type: spec.type,
+        name: spec.name.trim(),
+        ...(spec.description && spec.description.trim().length > 0
+            ? { description: spec.description.trim() }
+            : {}),
+        cases: spec.cases.map((testCase) => ({
+            id: normalizeTestId(testCase.id),
+            question: testCase.question.trim(),
+            ...(testCase.file && testCase.file.trim().length > 0
+                ? { file: testCase.file.trim() }
+                : {}),
+            ...(testCase.answer && testCase.answer.trim().length > 0
+                ? { answer: testCase.answer.trim() }
+                : {}),
+            ...(testCase.strictness && testCase.strictness.trim().length > 0
+                ? { strictness: testCase.strictness.trim() }
+                : {}),
+            ...(testCase.expect
+                ? {
+                    expect: {
+                        ...(testCase.expect.must_include && testCase.expect.must_include.length > 0
+                            ? { must_include: testCase.expect.must_include.map((value) => value.trim()).filter(Boolean) }
+                            : {}),
+                        ...(testCase.expect.must_include_one_of && testCase.expect.must_include_one_of.length > 0
+                            ? {
+                                must_include_one_of: testCase.expect.must_include_one_of
+                                    .map((group) => group.map((value) => value.trim()).filter(Boolean))
+                                    .filter((group) => group.length > 0),
+                            }
+                            : {}),
+                        ...(testCase.expect.must_not_include && testCase.expect.must_not_include.length > 0
+                            ? { must_not_include: testCase.expect.must_not_include.map((value) => value.trim()).filter(Boolean) }
+                            : {}),
+                        ...(typeof testCase.expect.min_words === "number"
+                            ? { min_words: testCase.expect.min_words }
+                            : {}),
+                        ...(typeof testCase.expect.max_words === "number"
+                            ? { max_words: testCase.expect.max_words }
+                            : {}),
+                    },
+                }
+                : {}),
+        })),
+    };
+    const parsed = TestSpecSchema.parse(normalizedSpec);
+    writeFileSync(filePath, `${JSON.stringify(serializeTestSpec(parsed), null, 2)}\n`);
+    return filePath;
+}

package/dist/lib/test-targets.d.ts

@@ -0,0 +1,5 @@
+import type { TestTargetCandidate } from "./test-types.js";
+export declare function listWorkspaceTestTargets(sourcePath: string): TestTargetCandidate[];
+export declare function createWorkspaceTestTarget(workspacePath: string, workspaceName: string, workflowId?: string): TestTargetCandidate;
+export declare function createRawTestTarget(sourcePath: string): TestTargetCandidate;
+export declare function listTestTargets(sourcePath: string): TestTargetCandidate[];

package/dist/lib/test-targets.js

@@ -0,0 +1,38 @@
+import { listWorkspacesForSourceFolder } from "./interf.js";
+import { computeWorkspaceHealth } from "./state.js";
+function summarizeTargetSortKey(target) {
+    return `${target.name}\u0000${target.workflow}`;
+}
+export function listWorkspaceTestTargets(sourcePath) {
+    return listWorkspacesForSourceFolder(sourcePath)
+        .map(({ path, config }) => createWorkspaceTestTarget(path, config.name, config.workflow ?? "interf"))
+        .sort((left, right) => summarizeTargetSortKey(left).localeCompare(summarizeTargetSortKey(right)));
+}
+export function createWorkspaceTestTarget(workspacePath, workspaceName, workflowId = "interf") {
+    const health = computeWorkspaceHealth(workspacePath);
+    return {
+        type: "workspace",
+        name: workspaceName,
+        path: workspacePath,
+        workflow: workflowId,
+        status: health.status,
+        stage: health.stage,
+        summary: health.summary,
+        eligible: health.status === "compiled",
+    };
+}
+export function createRawTestTarget(sourcePath) {
+    return {
+        type: "raw",
+        name: "raw",
+        path: sourcePath,
+        workflow: "raw",
+        status: "compiled",
+        stage: "raw",
+        summary: "Run the saved truth checks against an isolated sandbox of the raw files.",
+        eligible: true,
+    };
+}
+export function listTestTargets(sourcePath) {
+    return listWorkspaceTestTargets(sourcePath);
+}

package/dist/lib/test-types.d.ts

@@ -0,0 +1,17 @@
+import type { TestSpec } from "./schema.js";
+export type { TestCaseExpect, TestCase, TestSpec, TestCheckResult, TestCaseResult, TestTargetResult, TestTargetRun, } from "./schema.js";
+export type TestTargetType = "workspace" | "raw";
+export interface LoadedTestSpec extends TestSpec {
+    id: string;
+    filePath: string;
+}
+export interface TestTargetCandidate {
+    type: TestTargetType;
+    name: string;
+    path: string;
+    workflow: string;
+    status: "idle" | "running" | "compiled" | "stale" | "failed";
+    stage: string;
+    summary: string;
+    eligible: boolean;
+}

package/dist/lib/test-types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/test.d.ts

@@ -0,0 +1,4 @@
+export type { TestCaseExpect, TestCase, TestSpec, TestCheckResult, TestCaseResult, TestTargetResult, TestTargetRun, TestTargetType, LoadedTestSpec, TestTargetCandidate, } from "./test-types.js";
+export { listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, } from "./test-specs.js";
+export { createRawTestTarget, createWorkspaceTestTarget, listWorkspaceTestTargets, listTestTargets, } from "./test-targets.js";
+export { runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./test-execution.js";

package/dist/lib/test.js

@@ -0,0 +1,3 @@
+export { listTestSpecs, loadTestSpec, loadTestSpecFromFile, writeTestSpec, } from "./test-specs.js";
+export { createRawTestTarget, createWorkspaceTestTarget, listWorkspaceTestTargets, listTestTargets, } from "./test-targets.js";
+export { runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./test-execution.js";

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

@@ -3,4 +3,3 @@ export type { InterfUserConfig } from "./schema.js";
 export declare const USER_CONFIG_PATH: string;
 export declare function loadUserConfig(): InterfUserConfig | null;
 export declare function saveUserConfig(config: InterfUserConfig): void;
-//# sourceMappingURL=user-config.d.ts.map

package/dist/lib/user-config.js

@@ -13,4 +13,3 @@ export function saveUserConfig(config) {
     mkdirSync(INTERF_HOME, { recursive: true });
     writeFileSync(USER_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
 }
-//# sourceMappingURL=user-config.js.map

package/dist/lib/util.d.ts

@@ -1,4 +1,2 @@
-export declare const STATE_DIR = ".interf";
 export declare function slugify(input: string): string;
 export declare function isMarkdownFile(filePath: string): boolean;
-//# sourceMappingURL=util.d.ts.map

package/dist/lib/util.js

@@ -1,5 +1,4 @@
 import { extname } from "node:path";
-export const STATE_DIR = ".interf";
 export function slugify(input) {
     return input
         .toLowerCase()
@@ -11,4 +10,3 @@ export function slugify(input) {
 export function isMarkdownFile(filePath) {
     return extname(filePath).toLowerCase() === ".md";
 }
-//# sourceMappingURL=util.js.map

package/dist/lib/validate-helpers.d.ts

@@ -18,4 +18,3 @@ export interface InventoryFiles {
 }
 export declare function readInventoryFiles(inventory: Record<string, unknown> | null): InventoryFiles;
 export declare function readInventoryTotal(inventory: Record<string, unknown> | null, inventoryFiles?: InventoryFiles): number;
-//# sourceMappingURL=validate-helpers.d.ts.map

package/dist/lib/validate-helpers.js

@@ -69,4 +69,3 @@ export function readInventoryTotal(inventory, inventoryFiles) {
         return inventory.summary_total;
     return (inventoryFiles ?? readInventoryFiles(inventory)).files.length;
 }
-//# sourceMappingURL=validate-helpers.js.map

package/dist/lib/validate-workspace.d.ts

@@ -119,4 +119,3 @@ export declare function validateWorkspace(dirPath: string): WorkspaceValidationS
 export declare function validateWorkspaceSummarize(dirPath: string): WorkspaceSummarizeValidation;
 export declare function validateWorkspaceCompile(dirPath: string): WorkspaceCompileValidation;
 export declare function validateWorkspaceStructure(dirPath: string): WorkspaceStructureValidation;
-//# sourceMappingURL=validate-workspace.d.ts.map