@interf/compiler 0.6.1 → 0.6.4

package/dist/packages/testing/test-matrices.js

@@ -0,0 +1,96 @@
+import { z } from "zod";
+import { WorkflowIdPattern } from "../compiler/lib/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 TestMatrixDatasetSchema = 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(),
+    datasets: z.array(TestMatrixDatasetSchema).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 duplicateCompiledIds = findDuplicates(value.datasets);
+    for (const id of duplicateCompiledIds) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["datasets"],
+            message: `Duplicate dataset id 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/packages/testing/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(compiledPath: string, type: TestTargetType): string;
+export declare function targetTestRunGitignorePath(compiledPath: string, type: TestTargetType): string;
+export declare function targetTestSandboxesPath(compiledPath: string, type: TestTargetType): string;
+export declare function targetTestSandboxGitignorePath(compiledPath: 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/packages/testing/test-paths.js

@@ -0,0 +1,59 @@
+import { existsSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { targetTestRunsRootForCompiled, targetTestSandboxesRootForCompiled, compiledInterfConfigPath, } from "../compiler/compiled-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", "matrix", "specs");
+}
+export function testSpecTypePath(sourcePath, type) {
+    return join(testSpecRootPath(sourcePath), type);
+}
+function isDatasetTestsRootPath(artifactRootPath) {
+    return basename(dirname(artifactRootPath)) === "tests";
+}
+export function targetTestRunsPath(compiledPath, type) {
+    if (existsSync(compiledInterfConfigPath(compiledPath))) {
+        return join(targetTestRunsRootForCompiled(compiledPath), type);
+    }
+    if (isDatasetTestsRootPath(compiledPath)) {
+        return join(compiledPath, type === "raw" ? "file-as-is" : "compiled", "runs");
+    }
+    throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected a compiled context or interf/tests/<dataset> root.`);
+}
+export function targetTestRunGitignorePath(compiledPath, type) {
+    return join(targetTestRunsPath(compiledPath, type), ".gitignore");
+}
+export function targetTestSandboxesPath(compiledPath, type) {
+    if (existsSync(compiledInterfConfigPath(compiledPath))) {
+        return join(targetTestSandboxesRootForCompiled(compiledPath), type);
+    }
+    if (isDatasetTestsRootPath(compiledPath)) {
+        return join(compiledPath, type === "raw" ? "file-as-is" : "compiled", "sandboxes");
+    }
+    throw new Error(`Unsupported test artifact root: ${compiledPath}. Expected a compiled context or interf/tests/<dataset> root.`);
+}
+export function targetTestSandboxGitignorePath(compiledPath, type) {
+    return join(targetTestSandboxesPath(compiledPath, 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/packages/testing/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/packages/testing/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/packages/testing/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;
+    compiledPath: string | null;
+    preserve(destinationPath: string): string;
+    cleanup(): void;
+}
+export declare function createTestSandbox(target: TestTargetCandidate): TestSandbox;

package/dist/packages/testing/test-sandbox.js

@@ -0,0 +1,105 @@
+import { cpSync, existsSync, mkdirSync, mkdtempSync, renameSync, rmSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, relative, sep } from "node:path";
+import { refreshCompiledBootstrapGuidance } from "../agents/lib/compiled-bootstrap.js";
+import { readInterfConfig, resolveCompiledRawPath } from "../project-model/interf.js";
+import { projectRawTestQueryShell } from "../agents/lib/shells.js";
+import { compiledCompiledPathForDataset } from "../project-model/project-paths.js";
+import { saveCompiledInterfConfig } from "../project-model/source-config.js";
+import { projectRawSnapshot } from "../compiler/raw-snapshot.js";
+import { refreshCompiledArtifacts } from "../compiler/state.js";
+import { testRootForCompiled, stageExecutionShellsRoot, targetTestSandboxesRootForCompiled, workflowImprovementLoopsRoot, compiledQueryAcceptanceRoot, compiledRuntimeLogsRoot, } from "../compiler/compiled-paths.js";
+function toPortableRelativePath(fromPath, toPath) {
+    return relative(fromPath, toPath).split(sep).join("/");
+}
+function sanitizeCompiledArtifacts(compiledPath) {
+    for (const absolutePath of [
+        testRootForCompiled(compiledPath),
+        targetTestSandboxesRootForCompiled(compiledPath),
+        stageExecutionShellsRoot(compiledPath),
+        workflowImprovementLoopsRoot(compiledPath),
+        compiledRuntimeLogsRoot(compiledPath),
+        compiledQueryAcceptanceRoot(compiledPath),
+    ]) {
+        rmSync(absolutePath, { recursive: true, force: true });
+    }
+}
+export function createTestSandbox(target) {
+    let sandboxRoot = mkdtempSync(join(tmpdir(), "interf-test-sandbox-"));
+    let preserved = false;
+    const sandboxCompiledPath = () => (target.type === "compiled"
+        ? compiledCompiledPathForDataset(sandboxRoot, target.name)
+        : null);
+    const sandboxRawPath = () => (target.type === "compiled"
+        ? join(compiledCompiledPathForDataset(sandboxRoot, target.name), "raw")
+        : join(sandboxRoot, "raw"));
+    const sandboxTargetPath = () => (target.type === "compiled"
+        ? compiledCompiledPathForDataset(sandboxRoot, target.name)
+        : sandboxRoot);
+    try {
+        if (target.type === "compiled") {
+            mkdirSync(dirname(sandboxTargetPath()), { recursive: true });
+            cpSync(target.path, sandboxTargetPath(), { recursive: true });
+            sanitizeCompiledArtifacts(sandboxTargetPath());
+            const sandboxConfig = readInterfConfig(sandboxTargetPath());
+            if (!sandboxConfig) {
+                throw new Error(`Sandbox compiled context is missing interf.json: ${sandboxTargetPath()}`);
+            }
+            if (!existsSync(resolveCompiledRawPath(sandboxTargetPath(), sandboxConfig))) {
+                throw new Error(`Sandbox compiled context is missing its local raw snapshot: ${sandboxTargetPath()}. Rebuild the compiled context before testing it.`);
+            }
+            saveCompiledInterfConfig(sandboxTargetPath(), {
+                ...sandboxConfig,
+                checks: [],
+                source: {
+                    path: toPortableRelativePath(sandboxTargetPath(), sandboxRawPath()),
+                    dataset_path: toPortableRelativePath(sandboxTargetPath(), sandboxRawPath()),
+                },
+            });
+            refreshCompiledBootstrapGuidance(sandboxTargetPath());
+            refreshCompiledArtifacts(sandboxTargetPath(), { ensureViewSpec: true });
+        }
+        else {
+            projectRawSnapshot({
+                sourcePath: target.path,
+                destinationPath: sandboxRawPath(),
+                compiledPath: target.path,
+                mode: "link-or-copy",
+                prune: false,
+                preserveTimestamps: false,
+            });
+            projectRawTestQueryShell(sandboxTargetPath());
+        }
+    }
+    catch (error) {
+        rmSync(sandboxRoot, { recursive: true, force: true });
+        throw error;
+    }
+    return {
+        get rootPath() {
+            return sandboxRoot;
+        },
+        get rawPath() {
+            return sandboxRawPath();
+        },
+        get targetPath() {
+            return sandboxTargetPath();
+        },
+        get compiledPath() {
+            return sandboxCompiledPath();
+        },
+        preserve(destinationPath) {
+            mkdirSync(dirname(destinationPath), { recursive: true });
+            rmSync(destinationPath, { recursive: true, force: true });
+            renameSync(sandboxRoot, destinationPath);
+            sandboxRoot = destinationPath;
+            preserved = true;
+            return sandboxRoot;
+        },
+        cleanup() {
+            if (preserved)
+                return;
+            rmSync(sandboxRoot, { recursive: true, force: true });
+        },
+    };
+}

package/dist/packages/testing/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/packages/testing/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 "../shared/parse.js";
+import { TestSpecSchema } from "./lib/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 } : {}),
+        cases: 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/packages/testing/test-targets.d.ts

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

package/dist/packages/testing/test-targets.js

@@ -0,0 +1,38 @@
+import { listCompiledDatasetsForSourceFolder } from "../project-model/interf-detect.js";
+import { computeCompiledHealth } from "../compiler/state.js";
+function summarizeTargetSortKey(target) {
+    return `${target.name}\u0000${target.workflow}`;
+}
+export function listCompiledTestTargets(sourcePath) {
+    return listCompiledDatasetsForSourceFolder(sourcePath)
+        .map(({ path, config }) => createCompiledTestTarget(path, config.name, config.workflow ?? "interf"))
+        .sort((left, right) => summarizeTargetSortKey(left).localeCompare(summarizeTargetSortKey(right)));
+}
+export function createCompiledTestTarget(compiledPath, compiledName, workflowId = "interf") {
+    const health = computeCompiledHealth(compiledPath);
+    return {
+        type: "compiled",
+        name: compiledName,
+        path: compiledPath,
+        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 checks against an isolated sandbox of the raw files.",
+        eligible: true,
+    };
+}
+export function listTestTargets(sourcePath) {
+    return listCompiledTestTargets(sourcePath);
+}

package/dist/packages/testing/test-types.d.ts

@@ -0,0 +1,16 @@
+import type { TestSpec, TestTargetType } from "./lib/schema.js";
+export type { TestCaseExpect, TestCase, TestSpec, TestCheckResult, TestCaseResult, TestTargetResult, TestTargetRun, TestTargetType, } from "./lib/schema.js";
+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/packages/testing/test-types.js

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

package/dist/packages/testing/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, createCompiledTestTarget, listCompiledTestTargets, listTestTargets, } from "./test-targets.js";
+export { runTargetTests, runTargetTestsWithJudge, runTargetTestsAuto, saveTargetTestRun, } from "./test-execution.js";

package/dist/packages/testing/test.js

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

package/dist/packages/workflow-authoring/index.d.ts

@@ -0,0 +1,4 @@
+export * as authoring from "./workflow-authoring.js";
+export * as editSession from "./workflow-edit-session.js";
+export * as editUtils from "./lib/workflow-edit-utils.js";
+export * as improvement from "./workflow-improvement.js";

package/dist/packages/workflow-authoring/index.js

@@ -0,0 +1,4 @@
+export * as authoring from "./workflow-authoring.js";
+export * as editSession from "./workflow-edit-session.js";
+export * as editUtils from "./lib/workflow-edit-utils.js";
+export * as improvement from "./workflow-improvement.js";

package/dist/packages/workflow-authoring/lib/workflow-edit-utils.d.ts

@@ -0,0 +1,10 @@
+export declare function copyDirectory(sourcePath: string, targetPath: string): void;
+export declare function directoriesMatch(leftPath: string, rightPath: string): boolean;
+export interface WorkflowEditShellArtifacts {
+    rootPath: string;
+    workflowBeforePath: string;
+    workflowAfterPath: string;
+    promptLogPath: string;
+    eventLogPath: string;
+    statusLogPath: string;
+}

package/dist/packages/workflow-authoring/lib/workflow-edit-utils.js

@@ -0,0 +1,39 @@
+import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, } from "node:fs";
+import { join, relative } from "node:path";
+export function copyDirectory(sourcePath, targetPath) {
+    rmSync(targetPath, { recursive: true, force: true });
+    mkdirSync(targetPath, { recursive: true });
+    cpSync(sourcePath, targetPath, { recursive: true });
+}
+function listFileSnapshot(dirPath) {
+    const snapshot = new Map();
+    if (!existsSync(dirPath))
+        return snapshot;
+    const collect = (currentPath) => {
+        for (const entry of readdirSync(currentPath)) {
+            const fullPath = join(currentPath, entry);
+            const stat = statSync(fullPath);
+            if (stat.isDirectory()) {
+                collect(fullPath);
+                continue;
+            }
+            if (!stat.isFile())
+                continue;
+            snapshot.set(relative(dirPath, fullPath), readFileSync(fullPath, "utf8"));
+        }
+    };
+    collect(dirPath);
+    return snapshot;
+}
+export function directoriesMatch(leftPath, rightPath) {
+    const left = listFileSnapshot(leftPath);
+    const right = listFileSnapshot(rightPath);
+    if (left.size !== right.size)
+        return false;
+    for (const [relativePath, content] of left.entries()) {
+        if (right.get(relativePath) !== content) {
+            return false;
+        }
+    }
+    return true;
+}